Struct dipstick::Prometheus

pub struct Prometheus { /* private fields */ }

Prometheus Input holds a socket to a Prometheus server. The socket is shared between scopes opened from the Input.

Implementations

impl Prometheus

pub fn push_to(url: &str) -> Result<Prometheus>

Send metrics to a Prometheus “push gateway” at the URL provided. URL path must include group identifier labels job as shown in https://github.com/prometheus/pushgateway#command-line For example http://pushgateway.example.org:9091/metrics/job/some_job

Examples found in repository

examples/prometheus_labels.rs (line 7)

fn main() {
    let metrics = Prometheus::push_to("http://localhost:9091/metrics/job/prometheus_example")
        .expect("Prometheus Socket")
        .named("my_app")
        .metrics();

    AppLabel::set("abc", "456");
    ThreadLabel::set("xyz", "123");

    loop {
        metrics.counter("counter_a").count(123);
        metrics.timer("timer_a").interval_us(2000000);
        std::thread::sleep(Duration::from_millis(40));
    }
}

examples/proxy_multi.rs (line 28)

fn main() {
    // Placeholder to collect output targets
    // This will prefix all metrics with "my_stats"
    // before flushing them.
    let mut targets = MultiInput::new().named("my_stats");

    // Skip the metrics here... we just use this for the output
    // Follow the same pattern for Statsd, Graphite, etc.
    let prometheus = Prometheus::push_to("http://localhost:9091/metrics/job/dipstick_example")
        .expect("Prometheus Socket");
    targets = targets.add_target(prometheus);

    // Add stdout
    targets = targets.add_target(Stream::write_to_stdout());

    // Create the stats and drain targets
    let bucket = AtomicBucket::new();
    bucket.drain(targets);
    // Crucial, set the flush interval, otherwise risk hammering targets
    bucket.flush_every(Duration::from_secs(3));

    // Now wire up the proxy target with the stats and you're all set
    let proxy = Proxy::default();
    proxy.target(bucket.clone());

    // Example using the macro! Proxy sugar
    PROXY.target(bucket.named("global"));

    loop {
        // Using the default proxy
        proxy.counter("beans").count(100);
        proxy.timer("braincells").interval_us(420);
        // global example
        PROXY.counter("my_proxy_counter").count(123);
        PROXY.timer("my_proxy_timer").interval_us(2000000);
        std::thread::sleep(Duration::from_millis(100));
    }
}

Trait Implementations

impl Buffered for Prometheus

fn buffered(&self, buffering: Buffering) -> Self

Return a clone with the specified buffering set.

fn get_buffering(&self) -> Buffering

Return the current buffering strategy.

fn is_buffered(&self) -> bool

Returns false if the current buffering strategy is Buffering::Unbuffered. Returns true otherwise.

impl CachedInput for Prometheus

fn cached(self, max_size: usize) -> InputCache

Wrap an input with a metric definition cache. This can provide performance benefits for metrics that are dynamically defined at runtime on each access. Caching is useless if all metrics are statically declared or instantiated programmatically in advance and referenced by a long living variable.

impl Clone for Prometheus

fn clone(&self) -> Prometheus

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Prometheus

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Input for Prometheus

type SCOPE = PrometheusScope

The type of Scope returned byt this input.

fn metrics(&self) -> Self::SCOPE

Open a new scope from this input.

fn input(&self) -> Self::SCOPE

👎Deprecated since 0.7.2: Use metrics()

Open a new scope from this input.

fn new_scope(&self) -> Self::SCOPE

👎Deprecated since 0.8.0: Use metrics()

Open a new scope from this input.

impl QueuedInput for Prometheus

fn queued(self, max_size: usize) -> InputQueue

Wrap this output with an asynchronous dispatch queue of specified length.

impl WithAttributes for Prometheus

fn get_attributes(&self) -> &Attributes

Return attributes of component.

fn mut_attributes(&mut self) -> &mut Attributes

Return attributes of component for mutation.

fn with_attributes<F: Fn(&mut Attributes)>(&self, edit: F) -> Self

Clone the component and mutate its attributes at once.