Skip to content
WIP
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src
.gitignore
.travis.yml
Cargo.toml
LICENCE.md
README.md

README.md

Airbrake Rust

Build Status

The project is in the alpha stage and I don't recommend using it in production until it hits v1.0.0

Introduction

Airbrake Rust is an Airbrake notifier library for the Rust Programming language. The library provides minimalist API that enables the ability to send Rust errors to the Airbrake dashboard.

Key features

  • Uses the new Airbrake JSON API (v3)[link]
  • Simple, consistent and easy-to-use library API[link]
  • Awesome performance (check out our benchmarks)[link
  • Asynchronous error reporting[link]
  • Logging support via env_logger[link]
  • Support for proxying[link]
  • Support for environments[link]
  • Filters support (filter out sensitive or unwanted data that shouldn't be sent)[link]
  • Ability to ignore errors based on any condition[link]
  • SSL support (all communication with Airbrake is encrypted by default)

Installation

Cargo

Add the crate to your Cargo.toml:

[dependencies]
airbrake = "0.2"

Examples

Basic example

This is the minimal example that you can use to test Airbrake Rust with your project:

extern crate airbrake;

use std::num::ParseIntError;

fn double_number(number_str: &str) -> Result<i32, ParseIntError> {
   number_str.parse::<i32>().map(|n| 2 * n)
}

fn main() {
    let mut airbrake = airbrake::configure(|config| {
        config.project_id = "113743".to_owned();
        config.project_key = "81bbff95d52f8856c770bb39e827f3f6".to_owned();
    });

    match double_number("NOT A NUMBER") {
        Ok(n) => assert_eq!(n, 20),
        // Asynchronously sends the error to the dashboard.
        Err(err) => airbrake.notify(err),
    }

    // Joins worker threads.
    airbrake.close();
}

Configuration

project_key & project_id

You must set both project_id & project_key.

To find your project_id and project_key navigate to your project's General Settings and copy the values from the right sidebar.

let mut airbrake = airbrake::configure(|config| {
    config.project_id = "113743".to_owned();
    config.project_key = "81bbff95d52f8856c770bb39e827f3f6".to_owned();
});

host

By default, it is set to https://airbrake.io. A host is a web address containing a scheme ("http" or "https"), a host and a port. You can omit the port (80 will be assumed).

let mut airbrake = airbrake::configure(|config| {
    config.host = "http://localhost:8080".to_owned();
});

workers

The number of threads that handle notice sending. The default value is 1.

let mut airbrake = airbrake::configure(|config| {
    config.workers = 5;
});

proxy

If your server is not able to directly reach Airbrake, you can use proxy support. By default, Airbrake Rust uses direct connection. Note: proxy authentication is not supported yet.

let mut airbrake = airbrake::configure(|config| {
    config.proxy = "127.0.0.1:8080".to_owned();
});

app_version

The version of your application that you can pass to differentiate errors between multiple versions. It's not set by default.

let mut airbrake = airbrake::configure(|config| {
    config.app_version = "1.0.0".to_owned();
});

API

airbrake

airbrake.notify

Sends an error to Airbrake asynchronously. error must implement the std::error::Error trait. Returns ().

let mut airbrake = airbrake::configure(|config| {
    config.project_id = "123".to_owned();
    config.project_key = "321".to_owned();
});

airbrake.notify(std::io::Error::last_os_error());

airbrake.notify_sync

Sends an error to Airbrake synchronously. error must implement the std::error::Error trait. Returns rustc_serialize::json::Json. Accepts the same parameters as Airbrake.notify.

let mut airbrake = airbrake::configure(|config| {
    config.project_id = "123".to_owned();
    config.project_key = "321".to_owned();
});

airbrake.notify_sync(std::io::Error::last_os_error());
You can’t perform that action at this time.