* Adding back internals

* Making quality of life improvements to the types
* Adding testing to types

Author: msft-tsharp

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

@@ -42,7 +42,7 @@ impl log::Log for TelemetryCollectorLogBridge {
 
     fn flush(&self) {
         if unsafe { COLLECTOR_ENABLED } {
-            log_manager_provider().flush();
+            log_manager_provider().flush(false);
         }
     }
 }

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

@@ -1,8 +1,130 @@
-use std::os::raw::c_void;
+use std::{ffi::CStr, mem, os::raw::c_void};
 
-use crate::*;
+use crate::{client_library::Library, *};
 
-pub type evt_api_call_t = extern "stdcall" fn(context: *mut evt_context_t) -> evt_status_t;
+type evt_api_call_t = extern "stdcall" fn(context: *mut evt_context_t) -> evt_status_t;
+
+pub fn evt_open(config: *mut c_void) -> Option<evt_handle_t> {
+    let mut context: Box<evt_context_t> = Box::new(evt_context_t {
+        call: evt_call_t_EVT_OP_OPEN,
+        handle: 0,
+        data: config,
+        result: 0,
+        size: 0,
+    });
+
+    let raw_pointer = Box::into_raw(context);
+
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
+    let evt_api_call_default: evt_api_call_t =
+        unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
+
+    let result = evt_api_call_default(raw_pointer);
+
+    if result == -1 {
+        return Option::None;
+    }
+
+    context = unsafe { Box::from_raw(raw_pointer) };
+
+    return Some(context.handle.clone());
+}
+
+pub fn evt_close(handle: &evt_handle_t) -> evt_status_t {
+    let context: Box<evt_context_t> = Box::new(evt_context_t {
+        call: evt_call_t_EVT_OP_CLOSE,
+        handle: *handle,
+        data: std::ptr::null_mut(),
+        result: 0,
+        size: 0,
+    });
+
+    let raw_pointer = Box::into_raw(context);
+
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
+    let evt_api_call_default: evt_api_call_t =
+        unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
+
+    return evt_api_call_default(raw_pointer);
+}
+
+pub fn evt_upload(handle: &evt_handle_t) -> evt_status_t {
+    let context: Box<evt_context_t> = Box::new(evt_context_t {
+        call: evt_call_t_EVT_OP_UPLOAD,
+        handle: *handle,
+        data: std::ptr::null_mut(),
+        result: 0,
+        size: 0,
+    });
+
+    let raw_pointer = Box::into_raw(context);
+
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
+    let evt_api_call_default: evt_api_call_t =
+        unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
+
+    let status = evt_api_call_default(raw_pointer);
+
+    println!("UPLOAD STATUS >> {}", status);
+
+    status
+}
+
+pub fn evt_flush(handle: &evt_handle_t) -> evt_status_t {
+    let context: Box<evt_context_t> = Box::new(evt_context_t {
+        call: evt_call_t_EVT_OP_FLUSH,
+        handle: *handle,
+        data: std::ptr::null_mut(),
+        result: 0,
+        size: 0,
+    });
+
+    let raw_pointer = Box::into_raw(context);
+
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
+    let evt_api_call_default: evt_api_call_t =
+        unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
+
+    let status = evt_api_call_default(raw_pointer);
+
+    println!("FLUSH STATUS >> {}", status);
+
+    status
+}
+
+pub fn evt_log_vec(handle: &evt_handle_t, data_box: &mut Box<Vec<evt_prop>>) -> evt_status_t {
+    // Extract the inner vector from the Box
+    let data = &mut **data_box;
+
+    let val = unsafe { CStr::from_ptr(data[0].name) };
+    let val2 = unsafe { CStr::from_ptr(data[0].value.as_string) };
+    println!(
+        "MAGIC >> [{}]:{}",
+        val.to_str().unwrap(),
+        val2.to_str().unwrap()
+    );
+
+    let data_pointer = data.as_mut_ptr() as *mut c_void;
+    let data_len = data.len() as u32;
+
+    let context: Box<evt_context_t> = Box::new(evt_context_t {
+        call: evt_call_t_EVT_OP_LOG,
+        handle: *handle,
+        data: data_pointer,
+        result: 0,
+        size: data_len,
+    });
+
+    let raw_pointer = Box::into_raw(context);
+
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
+    let evt_api_call_default: evt_api_call_t =
+        unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
+
+    let status = evt_api_call_default(raw_pointer);
+
+    status
+}
 
 pub fn evt_log(handle: &evt_handle_t, data: &mut [evt_prop]) -> evt_status_t {
     let data_len = data.len() as u32;
@@ -18,7 +140,7 @@ pub fn evt_log(handle: &evt_handle_t, data: &mut [evt_prop]) -> evt_status_t {
 
     let raw_pointer = Box::into_raw(context);
 
-    let ct_lib = client_library::Library::new("ClientTelemetry.dll").unwrap();
+    let ct_lib = Library::new("ClientTelemetry.dll").unwrap();
     let evt_api_call_default: evt_api_call_t =
         unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
 

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

@@ -2,28 +2,24 @@
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 
-use chrono;
-use internals::evt_api_call_t;
 use log::debug;
 use once_cell::sync::Lazy;
-use std::{
-    ffi::{c_void, CString},
-    sync::RwLock,
-};
+use std::{ffi::c_void, sync::RwLock};
+use types::{StringProperty, TelemetryItem, TelemetryProperty};
 
 pub mod appender;
 mod client_library;
 mod helpers;
 mod internals;
+pub mod types;
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
 #[derive(Clone)]
 pub struct LogManager {
-    call_api: evt_api_call_t,
     is_started: bool,
-    configuration: Option<String>,
-    log_handle: Option<Box<i64>>,
+    configuration: StringProperty,
+    log_handle: Option<i64>,
 }
 
 /// The global `Tracer` provider singleton.
@@ -52,18 +48,22 @@ pub fn flush() {
         .write()
         .expect("GLOBAL_LOG_MANAGER RwLock poisoned");
 
-    log_manager.flush();
+    log_manager.flush(true);
+}
+
+pub fn offline_flush() {
+    let mut log_manager = GLOBAL_LOG_MANAGER
+        .write()
+        .expect("GLOBAL_LOG_MANAGER RwLock poisoned");
+
+    log_manager.flush(false);
 }
 
 impl LogManager {
     fn new() -> Self {
-        let ct_lib = client_library::Library::new("ClientTelemetry.dll").unwrap();
-        let call_api: evt_api_call_t = unsafe { ct_lib.get_proc("evt_api_call_default").unwrap() };
-
         LogManager {
-            call_api: call_api,
             is_started: false,
-            configuration: Option::None,
+            configuration: StringProperty::new("{}"),
             log_handle: Option::None,
         }
     }
@@ -72,147 +72,86 @@ impl LogManager {
      * Validates that a configuration has been set and
      */
     pub fn start(&mut self) -> bool {
-        if self.configuration.is_none() {
-            return false;
-        }
-
         if self.is_started {
             return true;
         }
 
-        // We don't need to leak this value
-        let config = self.configuration.clone().unwrap();
-        let c_str = Box::new(CString::new(config.as_str()).unwrap());
-        let config_data = c_str.as_ptr() as *mut c_void;
-
-        let mut context: Box<evt_context_t> = Box::new(evt_context_t {
-            call: evt_call_t_EVT_OP_OPEN,
-            handle: 0,
-            data: config_data,
-            result: 0,
-            size: 0,
-        });
+        let config_ptr = self.configuration.as_ptr() as *mut c_void;
+        let handle = internals::evt_open(config_ptr);
 
-        let raw_pointer = Box::into_raw(context);
-
-        let result = (self.call_api)(raw_pointer);
-
-        if result == -1 {
+        if handle.is_none() {
             debug!("LogManager.start: failed");
             return false;
         }
 
-        context = unsafe { Box::from_raw(raw_pointer) };
-        self.log_handle = Some(Box::new(context.handle));
+        self.log_handle = handle;
         self.is_started = true;
 
         debug!("LogManager.start: success");
 
         return true;
     }
 
-    pub fn flush(&mut self) {
+    pub fn flush(&mut self, upload: bool) {
         if self.is_started == false {
             return;
         }
 
-        let mut c_chars: Vec<i8> = Vec::new();
-        c_chars.push(0); // null
-        let null_config_data = c_chars.as_mut_ptr() as *mut c_void;
         let handle = self.log_handle.as_ref().unwrap();
-
-        let flush_ctx: Box<evt_context_t> = Box::new(evt_context_t {
-            call: evt_call_t_EVT_OP_FLUSH,
-            handle: *handle.as_ref(),
-            data: null_config_data,
-            result: 0,
-            size: 0,
-        });
-
-        let flush_ctx_ptr = Box::into_raw(flush_ctx);
-
-        let _ = (self.call_api)(flush_ctx_ptr);
+        internals::evt_flush(handle);
         debug!("LogManager.flush(EVT_OP_FLUSH)");
 
-        let upload_ctx: Box<evt_context_t> = Box::new(evt_context_t {
-            call: evt_call_t_EVT_OP_UPLOAD,
-            handle: *handle.as_ref(),
-            data: null_config_data,
-            result: 0,
-            size: 0,
-        });
-
-        let upload_ctx_ptr = Box::into_raw(upload_ctx);
-
-        let _ = (self.call_api)(upload_ctx_ptr);
-        debug!("LogManager.flush(EVT_OP_UPLOAD)");
+        if upload {
+            internals::evt_upload(handle);
+            debug!("LogManager.flush(EVT_OP_UPLOAD)");
+        }
     }
 
     pub fn stop(&mut self) {
         if self.is_started == false {
             return;
         }
 
-        let mut c_chars: Vec<i8> = Vec::new();
-        c_chars.push(0); // null
-        let null_config_data = c_chars.as_mut_ptr() as *mut c_void;
-        let handle = self.log_handle.as_ref().unwrap();
-
-        let flush_ctx: Box<evt_context_t> = Box::new(evt_context_t {
-            call: evt_call_t_EVT_OP_FLUSH,
-            handle: *handle.as_ref(),
-            data: null_config_data,
-            result: 0,
-            size: 0,
-        });
+        self.flush(false);
 
-        let flush_ctx_ptr = Box::into_raw(flush_ctx);
-
-        let _ = (self.call_api)(flush_ctx_ptr);
-
-        let close_ctx: Box<evt_context_t> = Box::new(evt_context_t {
-            call: evt_call_t_EVT_OP_CLOSE,
-            handle: *handle.as_ref(),
-            data: null_config_data,
-            result: 0,
-            size: 0,
-        });
-
-        let close_ctx_ptr = Box::into_raw(close_ctx);
-
-        let _ = (self.call_api)(close_ctx_ptr);
+        let handle = self.log_handle.as_ref().unwrap();
+        internals::evt_close(handle);
     }
 
     pub fn configure(&mut self, config: &str) {
-        self.configuration = Some(String::from(config.clone()));
+        self.configuration = StringProperty::new(config);
         debug!("LogManager.configure:\n{}", config);
     }
 
-    pub fn log_event(&self, name: &str) {
-        let evt_time = chrono::Utc::now();
+    pub fn trace(&mut self, message: &str) {
+        let mut item = TelemetryItem::new("trace");
 
-        let mut event_props: [evt_prop; 2] = [
-            helpers::string_prop("name", name, false),
-            helpers::int_prop("time", evt_time.timestamp_millis()),
-        ];
+        item.add_property(
+            "message",
+            TelemetryProperty::String(StringProperty::new(message)),
+        );
 
-        self.log(&mut event_props);
+        self.track_item(&item);
     }
 
-    pub fn trace(&self, message: &str) {
-        let evt_time = chrono::Utc::now();
+    pub fn track_item(&mut self, item: &TelemetryItem) {
+        let mut event_props = item.to_evt();
 
-        let mut event_props: [evt_prop; 3] = [
-            helpers::string_prop("name", "trace", false),
-            helpers::int_prop("time", evt_time.timestamp_millis()),
-            helpers::string_prop("message", message, false),
-        ];
+        debug!(
+            "LogManager.track_item(event_props_len:{})",
+            event_props.len()
+        );
 
-        self.log(&mut event_props);
+        let handle = self.log_handle.clone().unwrap();
+        internals::evt_log_vec(&handle, &mut event_props);
     }
 
-    pub fn log(&self, mut event_props: &mut [evt_prop]) {
-        debug!("LogManager.log(event_props_len:{})", event_props.len());
+    pub fn track_evt(&self, mut event_props: &mut [evt_prop]) {
+        debug!(
+            "LogManager.track_evt(event_props_len:{})",
+            event_props.len()
+        );
+
         let handle = self.log_handle.clone().unwrap();
         internals::evt_log(&handle, &mut event_props);
     }