refactor: keep fern [skip ci]

plugins/log/Cargo.toml

@@ -18,8 +18,6 @@ serde_repr = "0.1"
 byte-unit = "4.0"
 log = { workspace = true, features = ["kv_unstable"] }
 time = { version = "0.3", features = ["formatting"] }
-
-[target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\", target_os = \"dragonfly\", target_os = \"freebsd\", target_os = \"openbsd\", target_os = \"netbsd\"))".dependencies]
 fern = "0.6"
 
 [target."cfg(target_os = \"android\")".dependencies]

plugins/log/src/lib.rs

@@ -2,34 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-#[cfg(desktop)]
 use fern::FormatCallback;
-use log::LevelFilter;
 use log::{logger, RecordBuilder};
+use log::{LevelFilter, Record};
 use serde::Serialize;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::{iter::FromIterator, path::PathBuf};
+use std::{
+    fmt::Arguments,
+    fs::{self, File},
+    iter::FromIterator,
+    path::{Path, PathBuf},
+};
 use tauri::{
     plugin::{self, TauriPlugin},
-    Runtime,
+    Manager, Runtime,
 };
 
-#[cfg(desktop)]
-use desktop::*;
-#[cfg(desktop)]
 pub use fern;
 
-#[cfg(desktop)]
-mod desktop {
-    pub use std::{
-        fs::{self, File},
-        path::Path,
-    };
-    pub use tauri::Manager;
-}
-
 const DEFAULT_MAX_FILE_SIZE: u128 = 40000;
 const DEFAULT_ROTATION_STRATEGY: RotationStrategy = RotationStrategy::KeepOne;
 const DEFAULT_LOG_TARGETS: [LogTarget; 2] = [LogTarget::Stdout, LogTarget::LogDir];
@@ -151,24 +143,18 @@ fn log(
 }
 
 pub struct Builder {
-    #[cfg(desktop)]
     dispatch: fern::Dispatch,
     rotation_strategy: RotationStrategy,
     max_file_size: u128,
     targets: Vec<LogTarget>,
-    level_filter: Option<LevelFilter>,
-    levels: Vec<(Cow<'static, str>, log::LevelFilter)>,
 }
 
 impl Default for Builder {
     fn default() -> Self {
-        #[cfg(desktop)]
+        let format =
-        let dispatch = {
+            time::format_description::parse("[[[year]-[month]-[day]][[[hour]:[minute]:[second]]")
-            let format = time::format_description::parse(
-                "[[[year]-[month]-[day]][[[hour]:[minute]:[second]]",
-            )
                 .unwrap();
-            fern::Dispatch::new().format(move |out, message, record| {
+        let dispatch = fern::Dispatch::new().format(move |out, message, record| {
             out.finish(format_args!(
                 "{}[{}][{}] {}",
                 time::OffsetDateTime::now_utc().format(&format).unwrap(),
@@ -176,16 +162,12 @@ impl Default for Builder {
                 record.level(),
                 message
             ))
-            })
+        });
-        };
         Self {
-            #[cfg(desktop)]
             dispatch,
             rotation_strategy: DEFAULT_ROTATION_STRATEGY,
             max_file_size: DEFAULT_MAX_FILE_SIZE,
             targets: DEFAULT_LOG_TARGETS.into(),
-            level_filter: None,
-            levels: Vec::new(),
         }
     }
 }
@@ -205,37 +187,24 @@ impl Builder {
         self
     }
 
-    #[cfg(desktop)]
     pub fn format<F>(mut self, formatter: F) -> Self
     where
-        F: Fn(FormatCallback, &std::fmt::Arguments, &log::Record) + Sync + Send + 'static,
+        F: Fn(FormatCallback, &Arguments, &Record) + Sync + Send + 'static,
     {
         self.dispatch = self.dispatch.format(formatter);
         self
     }
 
     pub fn level(mut self, level_filter: impl Into<LevelFilter>) -> Self {
-        self.level_filter.replace(level_filter.into());
+        self.dispatch = self.dispatch.level(level_filter.into());
         self
     }
 
     pub fn level_for(mut self, module: impl Into<Cow<'static, str>>, level: LevelFilter) -> Self {
-        let module = module.into();
+        self.dispatch = self.dispatch.level_for(module, level);
-
-        if let Some((index, _)) = self
-            .levels
-            .iter()
-            .enumerate()
-            .find(|&(_, &(ref name, _))| name == &module)
-        {
-            self.levels.remove(index);
-        }
-
-        self.levels.push((module, level));
         self
     }
 
-    #[cfg(desktop)]
     pub fn filter<F>(mut self, filter: F) -> Self
     where
         F: Fn(&log::Metadata) -> bool + Send + Sync + 'static,
@@ -254,7 +223,7 @@ impl Builder {
         self
     }
 
-    #[cfg(all(desktop, feature = "colored"))]
+    #[cfg(feature = "colored")]
     pub fn with_colors(self, colors: fern::colors::ColoredLevelConfig) -> Self {
         let format =
             time::format_description::parse("[[[year]-[month]-[day]][[[hour]:[minute]:[second]]")
@@ -270,22 +239,23 @@ impl Builder {
         })
     }
 
-    pub fn build<R: Runtime>(#[allow(unused_mut)] mut self) -> TauriPlugin<R> {
+    pub fn build<R: Runtime>(mut self) -> TauriPlugin<R> {
-        #[cfg(desktop)]
-        {
-            if let Some(level) = self.level_filter {
-                self.dispatch = self.dispatch.level(level);
-            }
-            for (module, level) in self.levels {
-                self.dispatch = self.dispatch.level_for(module, level);
-            }
-        }
-
         plugin::Builder::new("log")
             .invoke_handler(tauri::generate_handler![log])
             .setup(move |app_handle| {
+                let app_name = &app_handle.package_info().name;
+
+                // setup targets
+                for target in &self.targets {
+                    let logger = match target {
+                        #[cfg(target_os = "android")]
+                        LogTarget::Stdout | LogTarget::Stderr => {
+                            fern::Output::call(android_logger::log)
+                        }
                         #[cfg(target_os = "ios")]
-                {
+                        LogTarget::Stdout | LogTarget::Stderr => {
+                            use std::{collections::HashMap, sync::Mutex};
+                            let loggers: Mutex<HashMap<String, oslog::OsLog>> = Default::default();
                             let mut subsystem = String::new();
                             let identifier = &app_handle.config().tauri.bundle.identifier;
                             let s = identifier.split('.');
@@ -298,67 +268,21 @@ impl Builder {
                             }
                             subsystem.push_str(&app_handle.package_info().crate_name);
 
-                    let mut logger = oslog::OsLogger::new(&subsystem);
+                            fern::Output::call(move |record| {
-                    logger =
+                                let mut loggers = loggers.lock().unwrap();
-                        logger.level_filter(self.level_filter.unwrap_or(log::LevelFilter::Trace));
+                                let pair =
-                    for (module, level) in self.levels {
+                                    loggers.entry(record.target().into()).or_insert_with(|| {
-                        logger = logger.category_level_filter(&module, level);
+                                        oslog::OsLog::new(&subsystem, record.target())
-                    }
+                                    });
-                    logger.init()?;
-                }
 
-                #[cfg(target_os = "android")]
+                                let message = format!("{}", record.args());
-                {
+                                (*pair).with_level(record.level().into(), &message);
-                    let mut logger = android_logger::Config::default();
+                            });
-                    if let Some(level_filter) = self.level_filter {
-                        if let Some(level) = level_filter.to_level() {
-                            logger = logger.with_min_level(level);
-                        }
-                    } else {
-                        logger = logger.with_min_level(log::Level::Trace);
-                    }
-                    if !self.levels.is_empty() {
-                        let mut filter = android_logger::FilterBuilder::new();
-                        for (module, level) in self.levels {
-                            filter.filter_module(&module, level);
-                        }
-                        logger = logger.with_filter(filter.build());
-                    }
-                    println!(
-                        "with tag {}",
-                        app_handle
-                            .config()
-                            .tauri
-                            .bundle
-                            .identifier
-                            .split('.')
-                            .rev()
-                            .next()
-                            .unwrap(),
-                    );
-                    android_logger::init_once(
-                        logger.with_tag(
-                            app_handle
-                                .config()
-                                .tauri
-                                .bundle
-                                .identifier
-                                .split('.')
-                                .rev()
-                                .next()
-                                .unwrap(),
-                        ),
-                    );
                         }
-
                         #[cfg(desktop)]
-                {
+                        LogTarget::Stdout => std::io::stdout().into(),
-                    let app_name = &app_handle.package_info().name;
+                        #[cfg(desktop)]
-                    // setup targets
+                        LogTarget::Stderr => std::io::stderr().into(),
-                    for target in &self.targets {
-                        self.dispatch = self.dispatch.chain(match target {
-                            LogTarget::Stdout => fern::Output::from(std::io::stdout()),
-                            LogTarget::Stderr => fern::Output::from(std::io::stderr()),
                         LogTarget::Folder(path) => {
                             if !path.exists() {
                                 fs::create_dir_all(path).unwrap();
@@ -372,6 +296,9 @@ impl Builder {
                             )?)?
                             .into()
                         }
+                        #[cfg(mobile)]
+                        LogTarget::LogDir => continue,
+                        #[cfg(desktop)]
                         LogTarget::LogDir => {
                             let path = app_handle.path_resolver().app_log_dir().unwrap();
                             if !path.exists() {
@@ -400,11 +327,11 @@ impl Builder {
                                 });
                             })
                         }
-                        });
+                    };
+                    self.dispatch = self.dispatch.chain(logger);
                 }
 
                 self.dispatch.apply()?;
-                }
 
                 Ok(())
             })
@@ -412,7 +339,6 @@ impl Builder {
     }
 }
 
-#[cfg(desktop)]
 fn get_log_file_path(
     dir: &impl AsRef<Path>,
     app_name: &str,