refactor + docs

Author: goenning

README.md

@@ -38,7 +38,9 @@ fn main() {
 }
 ```
 
-You can then start sending events from Rust by importing the `tauri_plugin_aptabase::EventTracker` trait and calling the `track_event` method on an `App`, `AppHandle` or `Window`. For the app_started event, for example, you could do this:
+You can then start sending events from Rust by importing the `tauri_plugin_aptabase::EventTracker` trait and calling the `track_event` method on `App`, `AppHandle` or `Window`. 
+
+As an example, you can add `app_started` and `app_exited` events like this:
 
 
 ```rust
@@ -51,8 +53,15 @@ fn main() {
             app.track_event("app_started", None);
             Ok(())
         })
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application")
+        .run(|handler, event| match event {
+            tauri::RunEvent::Exit { .. } => {
+                handler.track_event("app_exited", None);
+                handler.flush_events_blocking();
+            }
+            _ => {}
+        })
 }
 ```
 

src/client.rs

@@ -10,12 +10,6 @@ use crate::{
 
 static SESSION_TIMEOUT: Duration = Duration::from_secs(4 * 60 * 60);
 
-#[cfg(not(debug_assertions))]
-static DEFAULT_FLUSH_INTERVAL: Duration = Duration::from_secs(60);
-
-#[cfg(debug_assertions)]
-static DEFAULT_FLUSH_INTERVAL: Duration = Duration::from_secs(2);
-
 /// A tracking session.
 #[derive(Debug, Clone)]
 pub struct TrackingSession {
@@ -44,7 +38,7 @@ pub struct AptabaseClient {
 impl AptabaseClient {
 
     /// Creates a new Aptabase client.
-    pub fn new(config: Config, app_version: String) -> Self {
+    pub fn new(config: &Config, app_version: String) -> Self {
         let sys_info = sys::get_info();
 
         let is_enabled = !config.app_key.is_empty();
@@ -60,9 +54,8 @@ impl AptabaseClient {
     }
 
     /// Starts the event dispatcher loop.
-    pub(crate) fn start_polling(&self, interval: Option<Duration>) {
+    pub(crate) fn start_polling(&self, interval: Duration) {
         let dispatcher = self.dispatcher.clone();
-        let interval = interval.unwrap_or(DEFAULT_FLUSH_INTERVAL);
 
         tauri::async_runtime::spawn(async move {
             loop {

src/config.rs

@@ -1,20 +1,31 @@
+use std::time::Duration;
+
 use log::debug;
 use reqwest::Url;
 
+use crate::InitOptions;
+
 #[derive(Debug, Clone)]
 pub struct Config {
     pub app_key: String,
     pub ingest_api_url: Url,
+    pub flush_interval: Duration,
 }
 
 static LOCAL: &str = "http://localhost:3000";
 static US_REGION: &str = "https://us.aptabase.com";
 static EU_REGION: &str = "https://eu.aptabase.com";
 
+#[cfg(not(debug_assertions))]
+static DEFAULT_FLUSH_INTERVAL: Duration = Duration::from_secs(60);
+
+#[cfg(debug_assertions)]
+static DEFAULT_FLUSH_INTERVAL: Duration = Duration::from_secs(2);
+
 const VALID_REGIONS: &'static [&'static str] = &["US", "EU", "DEV", "SH"];
 
 impl Config {
-    pub fn new(app_key: String, host: Option<String>) -> Self {
+    pub fn new(app_key: String, opts: InitOptions) -> Self {
         let parts = app_key.split("-").collect::<Vec<&str>>();
         if parts.len() != 3 || !VALID_REGIONS.contains(&parts[1]) {
             debug!("The Aptabase App Key '{}' is invalid. Tracking will be disabled.", app_key);
@@ -26,7 +37,7 @@ impl Config {
             "US" => US_REGION.into(),
             "DEV" => LOCAL.into(),
             "SH" => {
-                if let Some(host) = host {
+                if let Some(host) = opts.host {
                     host
                 } else {
                     debug!("Host parameter must be defined when using Self-Hosted App Key. Tracking will be disabled.");
@@ -39,6 +50,7 @@ impl Config {
         Config {
             app_key,
             ingest_api_url: format!("{}/api/v0/events", base_url).parse().unwrap(),
+            flush_interval: opts.flush_interval.clone().unwrap_or(DEFAULT_FLUSH_INTERVAL)
         }
     }
 }
@@ -48,6 +60,7 @@ impl Default for Config {
         return Config {
             app_key: String::new(),
             ingest_api_url: Url::parse(LOCAL).unwrap(),
+            flush_interval: DEFAULT_FLUSH_INTERVAL,
         };
     }
 }

src/dispatcher.rs

@@ -15,7 +15,7 @@ pub(crate) struct EventDispatcher {
 }
 
 impl EventDispatcher {
-    pub fn new(config: Config) -> Self {
+    pub fn new(config: &Config) -> Self {
         let mut headers = HeaderMap::new();
         let app_key_header = HeaderValue::from_str(config.app_key.as_str())
             .expect("failed to define App Key header value");

src/lib.rs

@@ -4,14 +4,14 @@ mod commands;
 mod sys;
 mod dispatcher;
 
-use std::{sync::Arc, panic::PanicInfo, time::Duration, thread};
+use std::{sync::Arc, panic::PanicInfo, time::Duration};
 
 use config::Config;
 use serde_json::Value;
 use client::AptabaseClient;
 use tauri::{
   plugin::{TauriPlugin, self},
-    Runtime, Manager, App, AppHandle, Window, 
+    Runtime, Manager, App, AppHandle, Window,
 };
 
 #[derive(Default, Debug, Clone)]
@@ -58,11 +58,11 @@ impl Builder {
       plugin::Builder::new("aptabase")
         .invoke_handler(tauri::generate_handler![commands::track_event])
         .setup(|app| {
-          let cfg = Config::new(self.app_key, self.options.host);
+          let cfg = Config::new(self.app_key, self.options);
           let app_version = app.package_info().version.to_string();
-          let client = Arc::new(AptabaseClient::new(cfg, app_version));
+          let client = Arc::new(AptabaseClient::new(&cfg, app_version));
 
-          client.start_polling(self.options.flush_interval);
+          client.start_polling(cfg.flush_interval);
 
           if let Some(hook) = self.panic_hook {
             let hook_client = client.clone();