initial commit

Author: lalitb

opentelemetry-appender-log/src/lib.rs

@@ -131,6 +131,7 @@ where
             log_record.set_severity_text(record.level().as_str().into());
             log_record.set_body(AnyValue::from(record.args().to_string()));
             log_record.add_attributes(log_attributes(record.key_values()));
+            log_record.set_target(record.metadata().target().to_string());
 
             self.logger.emit(log_record);
         }

opentelemetry-appender-tracing/src/layer.rs

@@ -172,6 +172,7 @@ where
         let mut log_record = self.logger.create_log_record();
         log_record.set_severity_number(severity_of_level(meta.level()));
         log_record.set_severity_text(meta.level().to_string().into());
+        log_record.set_target(meta.target());
 
         let mut visitor = EventVisitor::new(&mut log_record);
         visitor.visit_metadata(meta);

opentelemetry-proto/src/transform/common.rs

@@ -42,21 +42,47 @@ pub mod tonic {
     #[cfg(any(feature = "trace", feature = "logs"))]
     use opentelemetry_sdk::Resource;
 
-    impl From<opentelemetry_sdk::InstrumentationLibrary> for InstrumentationScope {
-        fn from(library: opentelemetry_sdk::InstrumentationLibrary) -> Self {
+    impl
+        From<(
+            opentelemetry_sdk::InstrumentationLibrary,
+            Option<Cow<'static, str>>,
+        )> for InstrumentationScope
+    {
+        fn from(
+            data: (
+                opentelemetry_sdk::InstrumentationLibrary,
+                Option<Cow<'static, str>>,
+            ),
+        ) -> Self {
+            let (library, target) = data;
             InstrumentationScope {
-                name: library.name.into_owned(),
+                name: target
+                    .map(|t| t.replace("::", "."))
+                    .unwrap_or_else(|| library.name.into_owned()),
                 version: library.version.map(Cow::into_owned).unwrap_or_default(),
                 attributes: Attributes::from(library.attributes).0,
                 ..Default::default()
             }
         }
     }
 
-    impl From<&opentelemetry_sdk::InstrumentationLibrary> for InstrumentationScope {
-        fn from(library: &opentelemetry_sdk::InstrumentationLibrary) -> Self {
+    impl
+        From<(
+            &opentelemetry_sdk::InstrumentationLibrary,
+            Option<Cow<'static, str>>,
+        )> for InstrumentationScope
+    {
+        fn from(
+            data: (
+                &opentelemetry_sdk::InstrumentationLibrary,
+                Option<Cow<'static, str>>,
+            ),
+        ) -> Self {
+            let (library, target) = data;
             InstrumentationScope {
-                name: library.name.to_string(),
+                name: target
+                    .map(|t| t.replace("::", "."))
+                    .unwrap_or_else(|| library.name.to_string()),
                 version: library
                     .version
                     .as_ref()

opentelemetry-proto/src/transform/logs.rs

@@ -137,7 +137,7 @@ pub mod tonic {
                         .clone()
                         .map(Into::into)
                         .unwrap_or_default(),
-                    scope: Some(log_data.instrumentation.into()),
+                    scope: Some((log_data.instrumentation, log_data.record.target.clone()).into()),
                     log_records: vec![log_data.record.into()],
                 }],
             }

opentelemetry-proto/src/transform/metrics.rs

@@ -131,7 +131,7 @@ pub mod tonic {
     impl From<&SdkScopeMetrics> for TonicScopeMetrics {
         fn from(sm: &SdkScopeMetrics) -> Self {
             TonicScopeMetrics {
-                scope: Some((&sm.scope).into()),
+                scope: Some((&sm.scope, None).into()),
                 metrics: sm.metrics.iter().map(Into::into).collect(),
                 schema_url: sm
                     .scope

opentelemetry-proto/src/transform/trace.rs

@@ -61,7 +61,7 @@ pub mod tonic {
                         .as_ref()
                         .map(ToString::to_string)
                         .unwrap_or_default(),
-                    scope: Some(source_span.instrumentation_lib.into()),
+                    scope: Some((source_span.instrumentation_lib, None).into()),
                     spans: vec![Span {
                         trace_id: source_span.span_context.trace_id().to_bytes().to_vec(),
                         span_id: source_span.span_context.span_id().to_bytes().to_vec(),

opentelemetry-sdk/src/logs/record.rs

@@ -13,6 +13,9 @@ pub struct LogRecord {
     /// Event name. Optional as not all the logging API support it.
     pub event_name: Option<Cow<'static, str>>,
 
+    /// Target of the log record
+    pub target: Option<Cow<'static, str>>,
+
     /// Record timestamp
     pub timestamp: Option<SystemTime>,
 
@@ -42,6 +45,14 @@ impl opentelemetry::logs::LogRecord for LogRecord {
         self.event_name = Some(name.into());
     }
 
+    // Sets the `target` of a record
+    fn set_target<T>(&mut self, _target: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+        self.target = Some(_target.into());
+    }
+
     fn set_timestamp(&mut self, timestamp: SystemTime) {
         self.timestamp = Some(timestamp);
     }
@@ -116,6 +127,20 @@ mod tests {
     use std::borrow::Cow;
     use std::time::SystemTime;
 
+    #[test]
+    fn test_set_eventname() {
+        let mut log_record = LogRecord::default();
+        log_record.set_event_name("test_event");
+        assert_eq!(log_record.event_name, Some(Cow::Borrowed("test_event")));
+    }
+
+    #[test]
+    fn test_set_target() {
+        let mut log_record = LogRecord::default();
+        log_record.set_target("foo::bar");
+        assert_eq!(log_record.target, Some(Cow::Borrowed("foo::bar")));
+    }
+
     #[test]
     fn test_set_timestamp() {
         let mut log_record = LogRecord::default();

opentelemetry/src/logs/noop.rs

@@ -71,6 +71,14 @@ impl LogRecord for NoopLogRecord {
         V: Into<AnyValue>,
     {
     }
+
+    #[inline]
+    // Sets the `target` of a record
+    fn set_target<T>(&mut self, _target: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+    }
 }
 
 /// A no-op implementation of a [`Logger`]

opentelemetry/src/logs/record.rs

@@ -10,6 +10,11 @@ pub trait LogRecord {
     {
     }
 
+    /// Sets the `target` of a record
+    fn set_target<T>(&mut self, _target: T)
+    where
+        T: Into<Cow<'static, str>>;
+
     /// Sets the time when the event occurred measured by the origin clock, i.e. the time at the source.
     fn set_timestamp(&mut self, timestamp: SystemTime);