Remove unnecessary debug print

Author: stefanobaghino

examples/logs-enrichment/README.md

@@ -1,17 +1,31 @@
-# OpenTelemetry Log Appender for tracing -  Example
+# OpenTelemetry Log Processor Implemenation and Composition - Example
 
-This example shows how to use the opentelemetry-appender-tracing crate, which is a
-[logging
-appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge)
-that bridges logs from the [tracing crate](https://tracing.rs/tracing/#events) to
-OpenTelemetry. The example setups a LoggerProvider with stdout exporter, so logs
-are emitted to stdout.
+This example builds on top of the `logs-basic`, showing how to implement and compose
+`LogProcessor`s correctly.
 
-## Usage
+The `FilteringLogProcessor` applies a severity-based filtering. The main purpose is
+mostly to serve as a way to show how to compose processors by wrapping them into
+each other, in a way akin to the [delegation pattern](https://en.wikipedia.org/wiki/Delegation_pattern).
+
+The `SlowEnrichmentProcessor` simulates a (very!) slow processor adding information
+to the log captured by the OpenTelemetry SDK, which correctly ensures that the
+downstream processor's filtering is captured, avoiding unnecessary work.
 
-Run the following, and Logs emitted using [tracing](https://docs.rs/tracing/latest/tracing/)
-will be written out to stdout.
+## Usage
 
 ```shell
-cargo run
+cargo run --features="spec_unstable_logs_enabled"
 ```
+
+Notice:
+1. only the error log is enriched with the `enriched: true` attribute
+2. the slow enrichment process only happens for the error log, without unnecessary work
+
+## Extra credit
+
+Tweak the `SlowEnrichmentProcessor` by removing the implementation of `event_enabled`.
+The default implementation always accepts the event from the wrapped processor, even
+when it's set up to ignore a specific event. As a consequence, the slow enrichment
+processor will act on every log record, regardless of whether they are ultimately
+ignored. As a consequence, the filtering happening upstream will not be respected,
+causing info logs being enriched (with the resulting unnecessary work).

examples/logs-enrichment/src/main.rs

@@ -6,7 +6,7 @@ use opentelemetry_sdk::Resource;
 use tracing::{info, error};
 use tracing_subscriber::{prelude::*, EnvFilter};
 use opentelemetry::InstrumentationScope;
-use opentelemetry::logs::Severity;
+use opentelemetry::logs::{Severity, LogRecord};
 use opentelemetry_sdk::error::OTelSdkResult;
 
 fn main() {
@@ -90,7 +90,6 @@ impl<P: LogProcessor> LogProcessor for FilteringLogProcessor<P> {
 
     #[cfg(feature = "spec_unstable_logs_enabled")]
     fn event_enabled(&self, level: Severity, target: &str, name: Option<&str>) -> bool {
-        println!("filtering: severity is {level:?}");
         self.delegate.event_enabled(level, target, name) && level >= self.min_severity
     }
 }
@@ -111,8 +110,12 @@ impl<P: LogProcessor> SlowEnrichmentLogProcessor<P> {
 
 impl<P: LogProcessor> LogProcessor for SlowEnrichmentLogProcessor<P> {
     fn emit(&self, data: &mut SdkLogRecord, instrumentation: &InstrumentationScope) {
-        println!("slow enrichment log processor is waiting 1 s");
+        // Simulate an expensive enrichment step (e.g., fetching from a DB or service)
         sleep(Duration::from_secs(1));
+        // Enrich the log record with a custom attribute using the public API
+        data.add_attribute("enriched", true);
+        // You could also add more context, e.g., thread id, timestamp, etc.
+        // data.add_attribute("thread_id", format!("{:?}", std::thread::current().id()));
         self.delegate.emit(data, instrumentation);
     }
 
@@ -122,7 +125,10 @@ impl<P: LogProcessor> LogProcessor for SlowEnrichmentLogProcessor<P> {
 
     #[cfg(feature = "spec_unstable_logs_enabled")]
     fn event_enabled(&self, level: Severity, target: &str, name: Option<&str>) -> bool {
-        println!("slow enrichment: severity is {level:?}");
+        // It is important to call the delegate's event_enabled method to ensure that
+        // any filtering or logic implemented by downstream processors is respected.
+        // Skipping this call could result in logs being emitted that should have been filtered out
+        // or in bypassing other custom logic in the processor chain.
         self.delegate.event_enabled(level, target, name)
     }
 }