misc updates - working on memory safe logging

Author: msft-tsharp

wrappers/rust/oneds-telemetry/src/appender.rs

@@ -15,12 +15,14 @@ impl log::Log for TelemetryCollectorLogBridge {
 
     fn log(&self, record: &Record) {
         if unsafe { CONSOLE_ENABLED } && self.enabled(record.metadata()) {
-            let now = chrono::Utc::now();
+            let utc_now = chrono::Utc::now();
+            let nanos = utc_now.timestamp_subsec_nanos();
 
             println!(
-                "[{} {}] {} <{}> - {}: {}",
-                now.date_naive().to_string(),
-                now.time().format("%H:%M:%S"),
+                "[{} {}.{}] {} <{}> - {}: {}",
+                utc_now.date_naive().to_string(),
+                utc_now.time().format("%H:%M:%S"),
+                nanos,
                 record.target(),
                 record.module_path().unwrap(),
                 record.level(),
@@ -31,16 +33,16 @@ impl log::Log for TelemetryCollectorLogBridge {
         if unsafe { COLLECTOR_ENABLED }
             // Default
             && record.target() != "oneds_telemetry"
-            // Manually Set
-            && record.target() != "oneds_telemetry_internal"
+            // Items from deeper in the `oneds_telemetry` crate
+            && !record.target().starts_with("oneds_telemetry::")
         {
             log_manager_provider().trace(format!("{}", record.args()).as_str());
         }
     }
 
     fn flush(&self) {
         if unsafe { COLLECTOR_ENABLED } {
-            log_manager_provider().flush();
+            log_manager_provider().flush(true);
         }
     }
 }

wrappers/rust/oneds-telemetry/src/conversion.rs

@@ -0,0 +1,49 @@
+use crate::*;
+use std::ffi::{CStr, CString};
+use std::mem;
+use std::os::raw::c_char;
+
+/**
+ * This will leak memory
+ */
+pub fn to_leaky_c_str(value: &str) -> *const i8 {
+    let c_str = Box::new(CString::new(value.clone()).unwrap());
+    let ptr = c_str.as_ptr() as *const i8;
+    mem::forget(c_str);
+    return ptr;
+}
+
+pub fn to_c_str(value: &str) -> *const c_char {
+    let null_terminated_str = format!("{}\0", value);
+    let c_str = CStr::from_bytes_with_nul(null_terminated_str.as_bytes())
+        .expect("to_c_str: CString conversion failed");
+    c_str.as_ptr()
+}
+
+pub fn string_prop(name: &str, value: &str, is_pii: bool) -> evt_prop {
+    let mut pii_kind = 0;
+
+    if is_pii {
+        pii_kind = 1;
+    }
+
+    evt_prop {
+        name: to_leaky_c_str(name),
+        type_: evt_prop_t_TYPE_STRING,
+        value: evt_prop_v {
+            as_string: to_leaky_c_str(value),
+        },
+        piiKind: pii_kind,
+    }
+}
+
+pub fn int_prop(name: &str, value: i64) -> evt_prop {
+    evt_prop {
+        name: to_c_str(name),
+        type_: evt_prop_t_TYPE_INT64,
+        value: evt_prop_v {
+            as_int64: value.clone(),
+        },
+        piiKind: 0,
+    }
+}

wrappers/rust/oneds-telemetry/src/types.rs

@@ -0,0 +1,126 @@
+use std::{
+    collections::HashMap,
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
+
+use chrono::{DateTime, Utc};
+use log::debug;
+use once_cell::sync::Lazy;
+
+use crate::{evt_prop, evt_prop_t_TYPE_STRING, evt_prop_t_TYPE_TIME, evt_prop_v};
+
+#[derive(Clone, Debug)]
+pub struct StringProperty {
+    value: CString,
+}
+
+impl StringProperty {
+    pub fn new(value: &str) -> Self {
+        StringProperty {
+            value: CString::new(value).expect("Unable to convert value to CString"),
+        }
+    }
+
+    pub fn as_ptr(&self) -> *const c_char {
+        self.value.as_ptr()
+    }
+
+    fn to_str(&self) -> Result<&str, std::str::Utf8Error> {
+        unsafe { CStr::from_ptr(self.as_ptr()).to_str() }
+    }
+}
+
+static NAME_PROPERTY: Lazy<StringProperty> = Lazy::new(|| StringProperty::new("name"));
+static TIME_PROPERTY: Lazy<StringProperty> = Lazy::new(|| StringProperty::new("time"));
+
+#[derive(Clone, Debug)]
+pub enum TelemetryProperty {
+    String(StringProperty),
+    Int(i64),
+}
+
+pub type TelemetryPropertyBag = HashMap<&'static str, TelemetryProperty>;
+
+#[derive(Clone, Debug)]
+pub struct TelemetryItem {
+    name: StringProperty,
+    data: TelemetryPropertyBag,
+    time: Option<DateTime<Utc>>,
+}
+
+impl TelemetryItem {
+    pub fn new(name: &'static str) -> TelemetryItem {
+        TelemetryItem {
+            name: StringProperty::new(name),
+            data: TelemetryPropertyBag::new(),
+            time: Option::None,
+        }
+    }
+
+    pub fn new_with_time(name: &'static str, time: DateTime<Utc>) -> TelemetryItem {
+        TelemetryItem {
+            name: StringProperty::new(name),
+            data: TelemetryPropertyBag::new(),
+            time: Some(time),
+        }
+    }
+
+    pub fn add_property(&mut self, name: &'static str, value: TelemetryProperty) {
+        self.data.insert(name, value);
+    }
+
+    pub fn to_evt(&self) -> Vec<evt_prop> {
+        let mut properties = Vec::new();
+
+        properties.push(evt_prop {
+            name: NAME_PROPERTY.as_ptr(),
+            type_: evt_prop_t_TYPE_STRING,
+            value: evt_prop_v {
+                as_string: self.name.as_ptr(),
+            },
+            piiKind: 0,
+        });
+
+        if self.time != Option::None {
+            // Convert UTC time to a Unix timestamp as i64
+            let timestamp_i64 = self.time.unwrap().timestamp();
+
+            // Convert the i64 timestamp to u64
+            let millis = timestamp_i64 as u64;
+
+            properties.push(evt_prop {
+                name: TIME_PROPERTY.as_ptr(),
+                type_: evt_prop_t_TYPE_TIME,
+                value: evt_prop_v { as_time: millis },
+                piiKind: 0,
+            });
+        }
+
+        for prop in self.data.clone().into_iter() {}
+
+        debug!("{}", self.name.to_str().unwrap());
+
+        properties
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::types::StringProperty;
+
+    #[test]
+    fn validate_c_str_arrays() {
+        let mut iteration = 0;
+
+        while iteration < 5 {
+            iteration = iteration + 1;
+
+            let value1 = StringProperty::new("TEST_VALUE1");
+            let value2 = StringProperty::new("TEST_VALUE2");
+
+            assert_eq!("TEST_VALUE1", value1.to_str().unwrap());
+            assert_eq!("TEST_VALUE2", value2.to_str().unwrap());
+        }
+    }
+}