Rust

There is no Squasher crate for Rust. Send errors from Rust services with OpenTelemetry and the tracing crate, or post them to the HTTP API. This page is tested with the OpenTelemetry crates 0.33 on Rust 1.97.

Path	Use it when
OpenTelemetry	Your service logs with `tracing`, or you want traces too.
HTTP API	You want stack traces on the issue page, or fewer dependencies.

Send errors with OpenTelemetry

Add the crates

Cargo.toml

[dependencies]
opentelemetry = "0.33"
opentelemetry_sdk = "0.33"
opentelemetry-otlp = "0.33"
opentelemetry-appender-tracing = "0.33"
tracing = "0.1"
tracing-opentelemetry = "0.34"
tracing-subscriber = "0.3"

The default features of opentelemetry-otlp send OTLP over HTTP. Squasher does not accept OTLP over gRPC.

Set the exporter variables

export OTEL_SERVICE_NAME=checkout-api
export OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=production
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.squasher.ai
export OTEL_EXPORTER_OTLP_HEADERS="x-squasher-key=$SQUASHER_API_KEY"

OTLP requests do not need the project ID. To get a key, see Create an ingest key.

Send tracing spans and events

src/main.rs

use opentelemetry::trace::TracerProvider as _;
use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
use opentelemetry_otlp::{LogExporter, SpanExporter};
use opentelemetry_sdk::{logs::SdkLoggerProvider, trace::SdkTracerProvider, Resource};
use tracing_subscriber::filter::{LevelFilter, Targets};
use tracing_subscriber::prelude::*;

fn main() {
    // The exporters read OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS.
    // The resource reads OTEL_SERVICE_NAME and OTEL_RESOURCE_ATTRIBUTES.
    let resource = Resource::builder().build();
    let tracer_provider = SdkTracerProvider::builder()
        .with_batch_exporter(SpanExporter::builder().with_http().build().unwrap())
        .with_resource(resource.clone())
        .build();
    let logger_provider = SdkLoggerProvider::builder()
        .with_batch_exporter(LogExporter::builder().with_http().build().unwrap())
        .with_resource(resource)
        .build();

    // Keep the exporter's own logs out of the export.
    let no_exporter_logs = Targets::new()
        .with_default(LevelFilter::INFO)
        .with_target("opentelemetry", LevelFilter::OFF)
        .with_target("hyper", LevelFilter::OFF)
        .with_target("reqwest", LevelFilter::OFF);

    tracing_subscriber::registry()
        .with(tracing_opentelemetry::layer().with_tracer(tracer_provider.tracer("checkout")))
        .with(OpenTelemetryTracingBridge::new(&logger_provider).with_filter(no_exporter_logs))
        .with(tracing_subscriber::fmt::layer().with_filter(LevelFilter::INFO))
        .init();

    let _ = checkout("ord_123");

    // Send the queued spans and logs before the process exits.
    tracer_provider.shutdown().unwrap();
    logger_provider.shutdown().unwrap();
}

#[tracing::instrument]
fn checkout(order_id: &str) -> Result<(), String> {
    if let Err(error) = charge_card(order_id) {
        tracing::error!(%error, "checkout failed");
        return Err(error);
    }
    Ok(())
}

Without the Targets filter, the log bridge also exports the logs of the exporter itself.

How errors become issues

A tracing::error! event becomes a log record at error level. Squasher makes an issue titled with its message, here checkout failed. The fields, such as error, become attributes.
The same event inside an instrumented function also marks its span as an error. Squasher makes a second issue from the span, titled with the span name, here checkout.

A tracing event does not carry a stack trace, so these issues have none. For stack traces on the issue page, use the HTTP API.

Send errors with the HTTP API

Post each error to the ingest endpoint. This example uses reqwest with the blocking and json features, and serde_json.

src/squasher.rs

use serde_json::json;

pub fn capture_error(error: &dyn std::error::Error) -> Result<(), reqwest::Error> {
    let project_id = std::env::var("SQUASHER_PROJECT_ID").expect("SQUASHER_PROJECT_ID");
    let api_key = std::env::var("SQUASHER_API_KEY").expect("SQUASHER_API_KEY");
    reqwest::blocking::Client::new()
        .post(format!("https://ingest.squasher.ai/v1/ingest/{project_id}"))
        .header("x-squasher-key", api_key)
        .json(&json!({
            "message": error.to_string(),
            "level": "error",
            "environment": "production",
            // The backtrace of the place that reports the error.
            "stack": std::backtrace::Backtrace::force_capture().to_string(),
        }))
        .send()?
        .error_for_status()?;
    Ok(())
}

message is the only required field. stack is shown as the stack trace on the issue page. In an async service, use the async reqwest::Client instead. See the HTTP API for all fields and for batches.

Send a test error

OpenTelemetry: run tracing::error!("Squasher test error"), then shut down the providers.
HTTP API: run capture_error(&std::io::Error::other("Squasher test error")).

Then select Issues in the sidebar of your project. If the error does not appear, see Troubleshooting.

Give the setup to a coding agent

Copy this prompt into your coding agent to set up Rust the same way:

Send this Rust service's errors to Squasher with OpenTelemetry. There is no Squasher crate: do not add
one. Add opentelemetry, opentelemetry_sdk, opentelemetry-otlp, and opentelemetry-appender-tracing 0.33,
tracing-opentelemetry 0.34, and tracing-subscriber. Build HTTP span and log exporters, add
tracing_opentelemetry::layer() and OpenTelemetryTracingBridge (with the opentelemetry, hyper, and
reqwest targets filtered out) to the tracing subscriber, and shut down both providers before exit. Set
OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.squasher.ai and OTEL_EXPORTER_OTLP_HEADERS=x-squasher-key=<key>.
Verify with tracing::error!("Squasher test error").

Next steps

OpenTelemetry

See which OTLP data Squasher accepts.

HTTP API

See every field of the ingest endpoint.

Collector tail sampling

Keep error traces and sample the rest.

Troubleshooting

Find out why an event does not appear.

Get started

Guides

Send errors with OpenTelemetry

How errors become issues

Send errors with the HTTP API

Send a test error

Give the setup to a coding agent

Next steps

OpenTelemetry

HTTP API

Collector tail sampling

Troubleshooting

​Send errors with OpenTelemetry

​How errors become issues

​Send errors with the HTTP API

​Send a test error

​Give the setup to a coding agent

​Next steps

OpenTelemetry

HTTP API

Collector tail sampling

Troubleshooting

Send errors with OpenTelemetry

How errors become issues

Send errors with the HTTP API

Send a test error

Give the setup to a coding agent

Next steps