make log record type generic

Author: raphael-theriault-swi

lambda-extension/src/telemetry.rs

@@ -11,23 +11,23 @@ use tracing::{error, trace};
 
 /// Payload received from the Telemetry API
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
-pub struct LambdaTelemetry {
+pub struct LambdaTelemetry<L = String> {
     /// Time when the telemetry was generated
     pub time: DateTime<Utc>,
     /// Telemetry record entry
     #[serde(flatten)]
-    pub record: LambdaTelemetryRecord,
+    pub record: LambdaTelemetryRecord<L>,
 }
 
 /// Record in a LambdaTelemetry entry
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
 #[serde(tag = "type", content = "record", rename_all = "lowercase")]
-pub enum LambdaTelemetryRecord {
+pub enum LambdaTelemetryRecord<L = String> {
     /// Function log records
-    Function(String),
+    Function(L),
 
     /// Extension log records
-    Extension(String),
+    Extension(L),
 
     /// Platform init start record
     #[serde(rename = "platform.initStart", rename_all = "camelCase")]
@@ -319,12 +319,12 @@ mod deserialization_tests {
     use chrono::{TimeDelta, TimeZone};
 
     macro_rules! deserialize_tests {
-        ($($name:ident: $value:expr,)*) => {
+        ($($name:ident$(<$log:ty>)?: $value:expr,)*) => {
             $(
                 #[test]
                 fn $name() {
                     let (input, expected) = $value;
-                    let actual = serde_json::from_str::<LambdaTelemetry>(&input).expect("unable to deserialize");
+                    let actual = serde_json::from_str::<LambdaTelemetry$(<$log>)?>(&input).expect("unable to deserialize");
 
                     assert!(actual.record == expected);
                 }
@@ -339,12 +339,24 @@ mod deserialization_tests {
             LambdaTelemetryRecord::Function("hello world".to_string()),
         ),
 
+        // function (json)
+        function_json<bool>: (
+            r#"{"time": "2020-08-20T12:31:32.123Z","type": "function", "record": true}"#,
+            LambdaTelemetryRecord::Function(true),
+        ),
+
         // extension
         extension: (
             r#"{"time": "2020-08-20T12:31:32.123Z","type": "extension", "record": "hello world"}"#,
             LambdaTelemetryRecord::Extension("hello world".to_string()),
         ),
 
+        // extension (json)
+        extension_json<bool>: (
+            r#"{"time": "2020-08-20T12:31:32.123Z","type": "extension", "record": true}"#,
+            LambdaTelemetryRecord::Extension(true),
+        ),
+
         // platform.start
         platform_start: (
             r#"{"time":"2022-10-21T14:05:03.165Z","type":"platform.start","record":{"requestId":"459921b5-681c-4a96-beb0-81e0aa586026","version":"$LATEST","tracing":{"spanId":"24cd7d670fa455f0","type":"X-Amzn-Trace-Id","value":"Root=1-6352a70e-1e2c502e358361800241fd45;Parent=35465b3a9e2f7c6a;Sampled=1"}}}"#,
@@ -477,11 +489,11 @@ mod serialization_tests {
 
     use super::*;
     macro_rules! serialize_tests {
-        ($($name:ident: $value:expr,)*) => {
+        ($($name:ident$(<$log:ty>)?: $value:expr,)*) => {
             $(
                 #[test]
                 fn $name() {
-                    let (input, expected) = $value;
+                    let (input, expected): (LambdaTelemetry$(<$log>)?, &str) = $value;
                     let actual = serde_json::to_string(&input).expect("unable to serialize");
                     println!("Input: {:?}\n", input);
                     println!("Expected:\n {:?}\n", expected);
@@ -502,6 +514,14 @@ mod serialization_tests {
             },
             r#"{"time":"2023-11-28T12:00:09Z","type":"function","record":"hello world"}"#,
         ),
+        // function (json)
+        function_json<bool>: (
+            LambdaTelemetry {
+                time: Utc.with_ymd_and_hms(2023, 11, 28, 12, 0, 9).unwrap(),
+                record: LambdaTelemetryRecord::Function(true),
+            },
+            r#"{"time":"2023-11-28T12:00:09Z","type":"function","record":true}"#,
+        ),
         // extension
         extension: (
             LambdaTelemetry {
@@ -510,6 +530,14 @@ mod serialization_tests {
             },
             r#"{"time":"2023-11-28T12:00:09Z","type":"extension","record":"hello world"}"#,
         ),
+        // extension (json)
+        extension_json<bool>: (
+            LambdaTelemetry {
+                time: Utc.with_ymd_and_hms(2023, 11, 28, 12, 0, 9).unwrap(),
+                record: LambdaTelemetryRecord::Extension(true),
+            },
+            r#"{"time":"2023-11-28T12:00:09Z","type":"extension","record":true}"#,
+        ),
         //platform.Start
         platform_start: (
             LambdaTelemetry{