Crate tremor_otelapis

The code in the gen folder was seed by [tonic-build]. The code in the src folder extends the generated code with utility code to allow for convenient usage and definition of tonic-based gRPC servers. Specifically, this library is designed for use by the Tremor Project but has no dependencies on tremor and can be used standalone.

This library does not provide an API or SDK designed for use as a tracing facility. The official OpenTelemetry Rust project is a complete OpenTelemetry SDK designed for that purpose. It uses the same underlying protocol buffer definitions and will be a better target for projects that require OpenTelemetry based observability instrumentation and iteroperability with the wider observability ecosystem through third party crates.

This library is designed for system integration and interoperability and is not recommended for use as a tracing SDK or for instrumentation as that is well covered already by the OpenTelemetry Rust crate. For instrumentation, use the official crate.

For those projects that need basic interworking, interoperability or integration with OpenTelemetry based systems at a wire level, this project may be useful.

Example

The complete code can be found herehttps://github.com/tremor-rs/tremor-otelapis).

Cargo.toml:

[dependencies]
tremor-otelapis = { version = "0.1", features = ["otel-all"] }
tonic = { version = "0.4", features = ["tls"] }
prost = "0.7"
prost-types = "0.7"
tokio = { version = "1.1", features = ["rt-multi-thread", "time", "fs", "macros"] }

Example OpenTelemetry Log client

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let channel = Endpoint::from_static("http://0.0.0.0:4316")
        .connect()
        .await?;

    let mut client = LogsServiceClient::new(channel);

    let resource_logs = ResourceLogs {
        ...
    };

    client
        .export(ExportLogsServiceRequest {
            resource_logs: vec![resource_logs],
        })
        .await?;

    Ok(())
}

Example OpenTelemetry Log Server

fn on_logs(
    request: tonic::Request<ExportLogsServiceRequest>,
) -> Result<tonic::Response<ExportLogsServiceResponse>, tonic::Status> {
    println!("Got a request from {:?}", request.remote_addr());
    let reply = ExportLogsServiceResponse::default();
    Ok(tonic::Response::new(reply))
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "0.0.0.0:4317".parse()?;
    let svc = otelapis::logs::make_service(Box::new(on_logs));
    Server::builder().add_service(svc).serve(addr).await?;

    Ok(())
}

Example async-channel based OpenTelemetry for ease of integration with async runtimes such as tremor:

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "0.0.0.0:4317".parse()?;
    let (tx, rx) = bounded(128);
    let otel_collector_service = otelapis::all::make(addr, tx).await?;

    // ...

    loop {
        match rx.try_recv() {
            Ok(OpenTelemetryEvents::Metrics(metrics)) => {
                // Do something with metrics request
            }
            Ok(OpenTelemetryEvents::Logs(log)) => {
                // Do something with log request
            }
            Ok(OpenTelemetryEvents::Trace(trace)) => {
                // Do something with trace request
            }
            _ => error!("Unsupported"),
        };
   }

   // ...
}

[`otelapis`]: https://github.com/open-telemetry/opentelemetry-specification
[`tonic-build`]: https://github.com/hyperium/tonic/tree/master/tonic-build

Modules

all	A unified set of services that provide log, metrics and trace events
logs	This module defines a skeleton implementation of the open telemetry collector logging service
metrics	This module defines a skeleton implementation of the open telemetry collector metrics service
opentelemetry
trace	This module defines a skeleton implementation of the open telemetry collector tracing service