Merge pull request #852 from sdroege/bool-error-gstr

glib: Use actual function name in `glib::BoolError` and include function name/source file/line number in structured logs

Author: sdroege

glib/src/error.rs

@@ -158,30 +158,46 @@ pub trait ErrorDomain: Copy {
 #[macro_export]
 macro_rules! bool_error(
 // Plain strings
-    ($msg:expr) =>  {
-        $crate::BoolError::new($msg, file!(), module_path!(), line!())
-    };
+    ($msg:expr) => {{
+        $crate::BoolError::new(
+            $msg,
+            file!(),
+            $crate::function_name!(),
+            line!(),
+        )
+    }};
 
 // Format strings
-    ($($msg:tt)*) =>  { {
-        $crate::BoolError::new(format!($($msg)*), file!(), module_path!(), line!())
+    ($($msg:tt)*) =>  {{
+        $crate::BoolError::new(
+            format!($($msg)*),
+            file!(),
+            $crate::function_name!(),
+            line!(),
+        )
     }};
 );
 
 #[macro_export]
 macro_rules! result_from_gboolean(
 // Plain strings
-    ($ffi_bool:expr, $msg:expr) =>  {
-        $crate::BoolError::from_glib($ffi_bool, $msg, file!(), module_path!(), line!())
-    };
+    ($ffi_bool:expr, $msg:expr) => {{
+        $crate::BoolError::from_glib(
+            $ffi_bool,
+            $msg,
+            file!(),
+            $crate::function_name!(),
+            line!(),
+        )
+    }};
 
 // Format strings
-    ($ffi_bool:expr, $($msg:tt)*) =>  { {
+    ($ffi_bool:expr, $($msg:tt)*) =>  {{
         $crate::BoolError::from_glib(
             $ffi_bool,
             format!($($msg)*),
             file!(),
-            module_path!(),
+            $crate::function_name!(),
             line!(),
         )
     }};

glib/src/lib.rs

@@ -48,6 +48,49 @@ pub use self::variant_dict::VariantDict;
 pub use self::variant_iter::{VariantIter, VariantStrIter};
 pub use self::variant_type::{VariantTy, VariantTyIterator, VariantType};
 
+// Hack for the time being to retrieve the current function's name as a string.
+// Based on the stdext cratelicensed under the MIT license.
+//
+// Copyright (c) 2020 Igor Aleksanov
+//
+// Previous attempts to get such a macro into std:
+// * https://github.com/rust-lang/rfcs/pull/466
+// * https://github.com/rust-lang/rfcs/pull/1719
+// * https://github.com/rust-lang/rfcs/issues/1743
+// * https://github.com/rust-lang/rfcs/pull/2818
+// * ...
+// rustdoc-stripper-ignore-next
+/// This macro returns the name of the enclosing function.
+/// As the internal implementation is based on the [`std::any::type_name`], this macro derives
+/// all the limitations of this function.
+///
+/// ## Examples
+///
+/// ```rust
+/// mod bar {
+///     pub fn sample_function() {
+///         assert!(glib::function_name!().ends_with("bar::sample_function"));
+///     }
+/// }
+///
+/// bar::sample_function();
+/// ```
+///
+/// [`std::any::type_name`]: https://doc.rust-lang.org/std/any/fn.type_name.html
+#[macro_export]
+macro_rules! function_name {
+    () => {{
+        // Okay, this is ugly, I get it. However, this is the best we can get on a stable rust.
+        fn f() {}
+        fn type_name_of<T>(_: T) -> &'static str {
+            std::any::type_name::<T>()
+        }
+        let name = type_name_of(f);
+        // `3` is the length of the `::f`.
+        &name[..name.len() - 3]
+    }};
+}
+
 pub mod clone;
 #[macro_use]
 pub mod wrapper;

glib/src/log.rs

@@ -859,36 +859,57 @@ macro_rules! g_printerr {
 /// ```
 #[macro_export]
 macro_rules! log_structured {
-    ($log_domain:expr, $log_level:expr, {$($key:expr => $format:expr $(,$arg:expr)* $(,)?);+ $(;)?} $(,)?) => {
-        (|| {
-            let log_domain = <Option<&str> as std::convert::From<_>>::from($log_domain);
-            let log_domain_str = log_domain.unwrap_or_default();
-            let level: $crate::LogLevel = $log_level;
-            let field_count =
-                <[()]>::len(&[$($crate::log_structured_inner!(@clear $key)),+])
-                + log_domain.map(|_| 2usize).unwrap_or(1usize);
-
-            $crate::log_structured_array(
-                level,
-                &[
-                    $crate::LogField::new(
-                        $crate::gstr!("PRIORITY"),
-                        level.priority().as_bytes(),
-                    ),
-                    $(
-                        $crate::LogField::new(
-                            $crate::log_structured_inner!(@key $key),
-                            $crate::log_structured_inner!(@value $format $(,$arg)*),
-                        ),
-                    )+
+    ($log_domain:expr, $log_level:expr, {$($key:expr => $format:expr $(,$arg:expr)* $(,)?);+ $(;)?} $(,)?) => {{
+        let log_domain = <Option<&str> as std::convert::From<_>>::from($log_domain);
+        let log_domain_str = log_domain.unwrap_or_default();
+        let level: $crate::LogLevel = $log_level;
+        let field_count =
+            <[()]>::len(&[$($crate::log_structured_inner!(@clear $key)),+])
+            + log_domain.map(|_| 2usize).unwrap_or(1usize)
+            + 3;
+
+        let mut line = [0u8; 32]; // 32 decimal digits of line numbers should be enough!
+        let line = {
+            use std::io::Write;
+
+            let mut cursor = std::io::Cursor::new(&mut line[..]);
+            std::write!(&mut cursor, "{}", line!()).unwrap();
+            let pos = cursor.position() as usize;
+            &line[..pos]
+        };
+
+        $crate::log_structured_array(
+            level,
+            &[
+                $crate::LogField::new(
+                    $crate::gstr!("PRIORITY"),
+                    level.priority().as_bytes(),
+                ),
+                $crate::LogField::new(
+                    $crate::gstr!("CODE_FILE"),
+                    file!().as_bytes(),
+                ),
+                $crate::LogField::new(
+                    $crate::gstr!("CODE_LINE"),
+                    line,
+                ),
+                $crate::LogField::new(
+                    $crate::gstr!("CODE_FUNC"),
+                    $crate::function_name!().as_bytes(),
+                ),
+                $(
                     $crate::LogField::new(
-                        $crate::gstr!("GLIB_DOMAIN"),
-                        log_domain_str.as_bytes(),
+                        $crate::log_structured_inner!(@key $key),
+                        $crate::log_structured_inner!(@value $format $(,$arg)*),
                     ),
-                ][0..field_count],
-            )
-        })()
-    };
+                )+
+                $crate::LogField::new(
+                    $crate::gstr!("GLIB_DOMAIN"),
+                    log_domain_str.as_bytes(),
+                ),
+            ][0..field_count],
+        )
+    }};
 }
 
 #[doc(hidden)]

glib/tests/structured_log.rs

@@ -82,12 +82,22 @@ fn structured_log() {
             )
         })
         .collect::<Vec<_>>();
+
+    let path = if cfg!(windows) {
+        "glib\\tests\\structured_log.rs"
+    } else {
+        "glib/tests/structured_log.rs"
+    };
+
     assert_eq!(
         log[0],
         (
             LogLevel::Message,
             vec![
                 ("PRIORITY", "5" as &str),
+                ("CODE_FILE", path as &str),
+                ("CODE_LINE", "30" as &str),
+                ("CODE_FUNC", "structured_log::structured_log" as &str),
                 ("MY_META", "abc"),
                 ("MESSAGE", "normal with meta"),
                 ("MY_META2", "def"),
@@ -101,6 +111,9 @@ fn structured_log() {
             LogLevel::Message,
             vec![
                 ("PRIORITY", "5" as &str),
+                ("CODE_FILE", path as &str),
+                ("CODE_LINE", "40" as &str),
+                ("CODE_FUNC", "structured_log::structured_log" as &str),
                 ("MY_META", "abc"),
                 ("MESSAGE", "formatted with meta: 123 456"),
                 ("MY_META2", "defghi"),