Struct Client 

pub struct Client { /* private fields */ }

The client struct that handles sending metrics to the Dogstatsd server.

Implementations

impl Client

pub fn new(options: Options) -> Result<Self, DogstatsdError>

Create a new client from an options struct.

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();

pub fn incr<'a, I, S, T>(&self, stat: S, tags: I) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Increment a StatsD counter

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.incr("counter", &["tag:counter"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn incr_by_value<'a, I, S, T>( &self, stat: S, value: i64, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Increment a StatsD counter by the provided amount

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.incr_by_value("counter", 123, &["tag:counter"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn decr<'a, I, S, T>(&self, stat: S, tags: I) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Decrement a StatsD counter

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.decr("counter", &["tag:counter"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn decr_by_value<'a, I, S, T>( &self, stat: S, value: i64, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Decrement a StatsD counter by the provided amount

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.decr_by_value("counter", 23, &["tag:counter"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn count<'a, I, S, T>( &self, stat: S, count: i64, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Make an arbitrary change to a StatsD counter

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.count("counter", 42, &["tag:counter"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn time<'a, F, O, I, S, T>( &self, stat: S, tags: I, block: F, ) -> Result<O, (O, DogstatsdError)>

where F: FnOnce() -> O, I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Time how long it takes for a block of code to execute.

Examples

  use dogstatsd::{Client, Options};
  use std::thread;
  use std::time::Duration;

  let client = Client::new(Options::default()).unwrap();
  client.time("timer", &["tag:time"], || {
      thread::sleep(Duration::from_millis(200))
  }).unwrap_or_else(|(_, e)| println!("Encountered error: {}", e))

pub async fn async_time<'a, Fn, Fut, O, I, S, T>( &self, stat: S, tags: I, block: Fn, ) -> Result<O, (O, DogstatsdError)>

where Fn: FnOnce() -> Fut, Fut: Future<Output = O>, I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Time how long it takes for an async block of code to execute.

Examples

  use dogstatsd::{Client, Options};
  use std::thread;
  use std::time::Duration;

  async fn timer() {
      let client = Client::new(Options::default()).unwrap();
      client.async_time("timer", &["tag:time"], do_work)
      .await
      .unwrap_or_else(|(_, e)| println!("Encountered error: {}", e))
  }

pub fn timing<'a, I, S, T>(&self, stat: S, ms: i64, tags: I) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Send your own timing metric in milliseconds

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.timing("timing", 350, &["tag:timing"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn gauge<'a, I, S, SS, T>( &self, stat: S, val: SS, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Report an arbitrary value as a gauge

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.gauge("gauge", "12345", &["tag:gauge"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn histogram<'a, I, S, SS, T>( &self, stat: S, val: SS, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Report a value in a histogram

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.histogram("histogram", "67890", &["tag:histogram"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn distribution<'a, I, S, SS, T>( &self, stat: S, val: SS, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Report a value in a distribution

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.distribution("distribution", "67890", &["tag:distribution"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn set<'a, I, S, SS, T>(&self, stat: S, val: SS, tags: I) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Report a value in a set

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.set("set", "13579", &["tag:set"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn service_check<'a, I, S, T>( &self, stat: S, val: ServiceStatus, tags: I, options: Option<ServiceCheckOptions<'_>>, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, T: AsRef<str>,

Report the status of a service

Examples

  use dogstatsd::{Client, Options, ServiceStatus, ServiceCheckOptions};

  let client = Client::new(Options::default()).unwrap();
  client.service_check("redis.can_connect", ServiceStatus::OK, &["tag:service"], None)
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

  let options = ServiceCheckOptions {
    hostname: Some("my-host.localhost"),
    ..Default::default()
  };
  client.service_check("redis.can_connect", ServiceStatus::OK, &["tag:service"], Some(options))
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

  let all_options = ServiceCheckOptions {
    hostname: Some("my-host.localhost"),
    timestamp: Some(1510326433),
    message: Some("Message about the check or service")
  };
  client.service_check("redis.can_connect", ServiceStatus::OK, &["tag:service"], Some(all_options))
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn event<'a, I, S, SS, T>( &self, title: S, text: SS, tags: I, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Send a custom event as a title and a body

Examples

  use dogstatsd::{Client, Options};

  let client = Client::new(Options::default()).unwrap();
  client.event("Event Title", "Event Body", &["tag:event"])
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

pub fn event_with_options<'a, I, S, SS, T>( &self, title: S, text: SS, tags: I, options: Option<EventOptions<'a>>, ) -> DogstatsdResult

where I: IntoIterator<Item = T>, S: Into<Cow<'a, str>>, SS: Into<Cow<'a, str>>, T: AsRef<str>,

Send a custom event as a title and a body

Examples

  use dogstatsd::{Client, Options, EventOptions, EventAlertType, EventPriority};

  let client = Client::new(Options::default()).unwrap();
  let event_options = EventOptions::new()
    .with_timestamp(1638480000)
    .with_hostname("localhost")
    .with_priority(EventPriority::Normal)
    .with_alert_type(EventAlertType::Error);
  client.event_with_options("My Custom Event Title", "My Custom Event Body", &["tag:event"], Some(event_options))
      .unwrap_or_else(|e| println!("Encountered error: {}", e));

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.

impl Drop for Client

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for Client

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.