Struct datadog_statsd::client::Client

pub struct Client { /* fields omitted */ }

Client socket for statsd servers.

After creating a metric you can use Client to send metrics to the configured statsd server

Example

Creating a client and sending metrics is easy.

use datadog_statsd::client::Client;

let client = Client::new("127.0.0.1:8125", "myapp");
client.incr("some.metric.completed");

Implementations

impl Client

pub fn new<T: ToSocketAddrs>(
    host: T,
    prefix: &str,
    constant_tags: Option<Vec<&str>>
) -> Result<Client, StatsdError>

Construct a new statsd client given an host/port & prefix

pub fn incr(&self, metric: &str, tags: &Option<Vec<&str>>)

Increment a metric by 1

client.incr("metric.completed");

This modifies a counter with an effective sampling rate of 1.0.

pub fn decr(&self, metric: &str, tags: &Option<Vec<&str>>)

Decrement a metric by -1

client.decr("metric.completed");

This modifies a counter with an effective sampling rate of 1.0.

pub fn count(&self, metric: &str, value: f64, tags: &Option<Vec<&str>>)

Modify a counter by value.

Will increment or decrement a counter by value with a sampling rate of 1.0.

// Increment by 12
client.count("metric.completed", 12.0);

pub fn sampled_count(
    &self,
    metric: &str,
    value: f64,
    rate: f64,
    tags: &Option<Vec<&str>>
)

Modify a counter by value only x% of the time.

Will increment or decrement a counter by value with a custom sampling rate.

// Increment by 4 50% of the time.
client.sampled_count("metric.completed", 4, 0.5);

pub fn gauge(&self, metric: &str, value: f64, tags: &Option<Vec<&str>>)

Set a gauge value.

// set a gauge to 9001
client.gauge("power_level.observed", 9001.0);

pub fn timer(&self, metric: &str, value: f64, tags: &Option<Vec<&str>>)

Send a timer value.

The value is expected to be in ms.

// pass a duration value
client.timer("response.duration", 10.123);

pub fn time<F, R>(
    &self,
    metric: &str,
    tags: &Option<Vec<&str>>,
    callable: F
) -> R where
    F: FnOnce() -> R, 

Time a block of code.

The passed closure will be timed and executed. The block’s duration will be sent as a metric.

// pass a duration value
client.time("response.duration", || {
  // Your code here.
});

pub fn pipeline(&self) -> Pipeline

Get a pipeline struct that allows optimizes the number of UDP packets used to send multiple metrics

let mut pipeline = client.pipeline();
pipeline.incr("some.metric", 1);
pipeline.incr("other.metric", 1);
pipeline.send(&mut client);

pub fn histogram(&self, metric: &str, value: f64, tags: &Option<Vec<&str>>)

Send a histogram value.

// pass response size value
client.histogram("response.size", 128.0);

pub fn event(
    &self,
    title: &str,
    text: &str,
    alert_type: AlertType,
    tags: &Option<Vec<&str>>
)

Send a event.

// pass a app start event
client.event("MyApp Start", "MyApp Details", AlertType::Info, &Some(vec!["tag1", "tag2:test"]));

pub fn service_check(
    &self,
    service_check_name: &str,
    status: ServiceCheckStatus,
    tags: &Option<Vec<&str>>
)

Send a service check.

// pass a app status
client.service_check("MyApp", ServiceCheckStatus::Ok, &Some(vec!["tag1", "tag2:test"]));