Also print datetime in human friendly format for stdout (#1206)

Author: cijothomas

opentelemetry-stdout/src/common.rs

@@ -5,6 +5,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
+use chrono::{LocalResult, TimeZone, Utc};
 use ordered_float::OrderedFloat;
 use serde::{Serialize, Serializer};
 
@@ -239,6 +240,41 @@ impl From<opentelemetry_sdk::Scope> for Scope {
     }
 }
 
+pub(crate) fn as_human_readable<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let duration_since_epoch = time.duration_since(UNIX_EPOCH).unwrap_or_default();
+
+    match Utc.timestamp_opt(
+        duration_since_epoch.as_secs() as i64,
+        duration_since_epoch.subsec_nanos(),
+    ) {
+        LocalResult::Single(datetime) => serializer.serialize_str(
+            datetime
+                .format("%Y-%m-%d %H:%M:%S.%3f")
+                .to_string()
+                .as_ref(),
+        ),
+        _ => Err(serde::ser::Error::custom("Invalid Timestamp.")),
+    }
+}
+
+#[allow(dead_code)]
+// Used for serde serialization. Not used in traces.
+pub(crate) fn as_opt_human_readable<S>(
+    time: &Option<SystemTime>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match time {
+        None => serializer.serialize_none(),
+        Some(time) => as_human_readable(time, serializer),
+    }
+}
+
 pub(crate) fn as_unix_nano<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
@@ -250,3 +286,17 @@ where
 
     serializer.serialize_u128(nanos)
 }
+
+#[allow(dead_code)]
+pub(crate) fn as_opt_unix_nano<S>(
+    time: &Option<SystemTime>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match time {
+        None => serializer.serialize_none(),
+        Some(time) => as_unix_nano(time, serializer),
+    }
+}

opentelemetry-stdout/src/logs/transform.rs

@@ -1,8 +1,11 @@
 use std::{borrow::Cow, collections::HashMap, time::SystemTime};
 
-use crate::common::{as_unix_nano, KeyValue, Resource, Scope, Value};
+use crate::common::{
+    as_human_readable, as_opt_human_readable, as_opt_unix_nano, as_unix_nano, KeyValue, Resource,
+    Scope, Value,
+};
 use opentelemetry_sdk::AttributeSet;
-use serde::{Serialize, Serializer};
+use serde::Serialize;
 
 /// Transformed logs data that can be serialized.
 #[derive(Debug, Serialize)]
@@ -69,13 +72,14 @@ struct ScopeLogs {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct LogRecord {
-    #[serde(
-        skip_serializing_if = "Option::is_none",
-        serialize_with = "opt_as_unix_nano"
-    )]
+    #[serde(serialize_with = "as_opt_unix_nano")]
     time_unix_nano: Option<SystemTime>,
+    #[serde(serialize_with = "as_opt_human_readable")]
+    time: Option<SystemTime>,
     #[serde(serialize_with = "as_unix_nano")]
     observed_time_unix_nano: SystemTime,
+    #[serde(serialize_with = "as_human_readable")]
+    observed_time: SystemTime,
     severity_number: u32,
     #[serde(skip_serializing_if = "Option::is_none")]
     severity_text: Option<Cow<'static, str>>,
@@ -110,7 +114,9 @@ impl From<opentelemetry_sdk::export::logs::LogData> for LogRecord {
                 .map(|c| c.trace_flags.map(|f| f.to_u8()))
                 .unwrap_or_default(),
             time_unix_nano: value.record.timestamp,
+            time: value.record.timestamp,
             observed_time_unix_nano: value.record.observed_timestamp,
+            observed_time: value.record.observed_timestamp,
             severity_number: value
                 .record
                 .severity_number
@@ -132,10 +138,3 @@ impl From<opentelemetry_sdk::export::logs::LogData> for LogRecord {
         }
     }
 }
-
-fn opt_as_unix_nano<S>(time: &Option<SystemTime>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    as_unix_nano(time.as_ref().unwrap(), serializer)
-}

opentelemetry-stdout/src/metrics/transform.rs

@@ -1,13 +1,10 @@
 use crate::common::{AttributeSet, KeyValue, Resource, Scope};
-use chrono::{LocalResult, TimeZone, Utc};
 use opentelemetry::{global, metrics::MetricsError};
 use opentelemetry_sdk::metrics::data;
 use serde::{Serialize, Serializer};
-use std::{
-    any::Any,
-    borrow::Cow,
-    time::{SystemTime, UNIX_EPOCH},
-};
+use std::{any::Any, borrow::Cow, time::SystemTime};
+
+use crate::common::{as_human_readable, as_opt_human_readable, as_opt_unix_nano, as_unix_nano};
 
 /// Transformed metrics data that can be serialized
 #[derive(Serialize, Debug, Clone)]
@@ -328,58 +325,6 @@ struct Exemplar {
     trace_id: String,
 }
 
-fn as_human_readable<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let duration_since_epoch = time.duration_since(UNIX_EPOCH).unwrap_or_default();
-
-    match Utc.timestamp_opt(
-        duration_since_epoch.as_secs() as i64,
-        duration_since_epoch.subsec_nanos(),
-    ) {
-        LocalResult::Single(datetime) => serializer.serialize_str(
-            datetime
-                .format("%Y-%m-%d %H:%M:%S.%3f")
-                .to_string()
-                .as_ref(),
-        ),
-        _ => Err(serde::ser::Error::custom("Invalid Timestamp.")),
-    }
-}
-
-fn as_opt_human_readable<S>(time: &Option<SystemTime>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    match time {
-        None => serializer.serialize_none(),
-        Some(time) => as_human_readable(time, serializer),
-    }
-}
-
-fn as_unix_nano<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let nanos = time
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_nanos();
-
-    serializer.serialize_u128(nanos)
-}
-
-fn as_opt_unix_nano<S>(time: &Option<SystemTime>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    match time {
-        None => serializer.serialize_none(),
-        Some(time) => as_unix_nano(time, serializer),
-    }
-}
-
 impl<T: Into<DataValue> + Copy> From<&data::Exemplar<T>> for Exemplar {
     fn from(value: &data::Exemplar<T>) -> Self {
         Exemplar {

opentelemetry-stdout/src/trace/transform.rs

@@ -1,4 +1,4 @@
-use crate::common::{as_unix_nano, KeyValue, Resource, Scope};
+use crate::common::{as_human_readable, as_unix_nano, KeyValue, Resource, Scope};
 use opentelemetry_sdk::AttributeSet;
 use serde::{Serialize, Serializer};
 use std::{borrow::Cow, collections::HashMap, time::SystemTime};
@@ -73,8 +73,12 @@ struct Span {
     kind: SpanKind,
     #[serde(serialize_with = "as_unix_nano")]
     start_time_unix_nano: SystemTime,
+    #[serde(serialize_with = "as_human_readable")]
+    start_time: SystemTime,
     #[serde(serialize_with = "as_unix_nano")]
     end_time_unix_nano: SystemTime,
+    #[serde(serialize_with = "as_human_readable")]
+    end_time: SystemTime,
     attributes: Vec<KeyValue>,
     dropped_attributes_count: u32,
     #[serde(skip_serializing_if = "Vec::is_empty")]
@@ -98,7 +102,9 @@ impl From<opentelemetry_sdk::export::trace::SpanData> for Span {
             name: value.name,
             kind: value.span_kind.into(),
             start_time_unix_nano: value.start_time,
+            start_time: value.start_time,
             end_time_unix_nano: value.end_time,
+            end_time: value.end_time,
             dropped_attributes_count: value.attributes.dropped_count(),
             attributes: value.attributes.into_iter().map(Into::into).collect(),
             dropped_events_count: value.events.dropped_count(),