how to send logs and traces (corraleted)

[nbari]

I can send traces, but I can't send logs, I am trying with this:

use anyhow::Result;
use opentelemetry::{global, trace::TracerProvider, KeyValue};
use opentelemetry_appender_tracing::layer;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::{logs::LoggerProvider, runtime::Tokio, trace::Config, Resource};
use std::time::Duration;
use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::{fmt, layer::SubscriberExt, EnvFilter, Registry};

pub fn init(verbosity_level: tracing::Level) -> Result<()> {
    let tracer_exporter = opentelemetry_otlp::new_exporter()
        .tonic()
        .with_timeout(Duration::from_secs(3));

    let provider = opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(tracer_exporter)
        .with_trace_config(Config::default().with_resource(Resource::new(vec![
            KeyValue::new("service.name", env!("CARGO_PKG_NAME")),
            KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),
        ])))
        .install_batch(Tokio)?;

    let tracer = provider
        .tracer_builder(env!("CARGO_PKG_NAME"))
        .with_version(env!("CARGO_PKG_VERSION"))
        .build();

    global::set_tracer_provider(provider);

    let otel_trace_layer = OpenTelemetryLayer::new(tracer);

    let log_exporter = opentelemetry_otlp::new_exporter()
        .tonic()
        .with_timeout(Duration::from_secs(3))
        .build_log_exporter()?;

    let log_provider = LoggerProvider::builder()
        .with_resource(Resource::new(vec![KeyValue::new(
            env!("CARGO_PKG_NAME"),
            env!("CARGO_PKG_VERSION"),
        )]))
        .with_simple_exporter(log_exporter)
        .build();

    let otel_logs_layer = layer::OpenTelemetryTracingBridge::new(&log_provider);

    let fmt_layer = fmt::layer()
        .with_file(true)
        .with_line_number(true)
        .with_thread_ids(false)
        .with_thread_names(false)
        .with_target(false)
        .json();

    let env_filter = EnvFilter::builder()
        .with_default_directive(verbosity_level.into())
        .from_env_lossy();

    let subscriber = Registry::default()
        .with(fmt_layer)
        .with(otel_trace_layer)
        .with(otel_logs_layer)
        .with(env_filter);

    Ok(tracing::subscriber::set_global_default(subscriber)?)
}

The app gets stuck/idle if I use the otel_logs_layer in the subscriber, it only works after I comment it out:

    let subscriber = Registry::default()
        .with(fmt_layer)
        .with(otel_trace_layer)
        //.with(otel_logs_layer)
        .with(env_filter);

I am sending this to an otel-collector OTEL_EXPORTER_OTLP_ENDPOINT, any idea of how this should be done?

Without using the logger (because of the fmt) I see logs via stdout but I would like to have traces/logs so that the collector can push both to the provider.

[cijothomas]

Can you start with https://github.com/open-telemetry/opentelemetry-rust/tree/main/opentelemetry-otlp/examples/basic-otlp and see if it works and then modify it to your needs?

[nbari]

It turns out I indeed was sending logs but there is probably a problem with my exporter (quickwit) that is not accepting/writing the log, I also noticed that within the Trace I see logs so maybe I will only keep traces since keeps the span and the logs, I mean all the output of debug!, info!, error! etc is within the log: of the span produced