JSON formatter

nightly-examples/Cargo.toml

@@ -13,8 +13,9 @@ edition = "2018"
 
 [dev-dependencies]
 tracing = "0.1"
-tracing-subscriber = { version = "0.1", path = "../tracing-subscriber" }
+tracing-subscriber = { version = "0.1", path = "../tracing-subscriber", features = ["json"] }
 tracing-futures = { path = "../tracing-futures", default-features = false, features = ["std-future"] }
 tokio = { git = "https://github.com/tokio-rs/tokio.git" }
 tracing-attributes = { path = "../tracing-attributes" }
 futures-preview = "0.3.0-alpha.18"
+clap = "2.33"

nightly-examples/examples/proxy_server.rs

@@ -9,7 +9,7 @@
 //!
 //! You can showcase this by running this in one terminal:
 //!
-//!     cargo +nightly run --example proxy_server
+//!     cargo +nightly run --example proxy_server -- --log_format=(plain|json)
 //!
 //! This in another terminal
 //!
@@ -29,12 +29,11 @@ use tokio::{
     net::{TcpListener, TcpStream},
     prelude::*,
 };
-
 use tracing::{debug, debug_span, info, warn};
 use tracing_attributes::instrument;
 use tracing_futures::Instrument;
-
-use std::{env, net::SocketAddr};
+use clap::{App, Arg, ArgMatches, arg_enum, value_t};
+use std::net::SocketAddr;
 
 #[instrument]
 async fn transfer(
@@ -84,23 +83,50 @@ async fn transfer(
     Ok(())
 }
 
+arg_enum! {
+    #[derive(PartialEq, Debug)]
+    pub enum LogFormat {
+        Plain,
+        Json,
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    use tracing_subscriber::{EnvFilter, FmtSubscriber};
-
-    let subscriber = FmtSubscriber::builder()
-        .with_env_filter(EnvFilter::from_default_env().add_directive("proxy_server=trace".parse()?))
-        .finish();
-    tracing::subscriber::set_global_default(subscriber)?;
-
-    let listen_addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8081".to_string());
+    let matches = App::new("Proxy Server Exemple")
+        .version("1.0")
+        .arg(
+            Arg::with_name("log_format")
+                .possible_values(&LogFormat::variants())
+                .case_insensitive(true)
+                .long("log_format")
+                .value_name("log_format")
+                .help("Formating of the logs")
+                .required(false)
+                .takes_value(true),
+        )
+        .arg(
+            Arg::with_name("listen_addr")
+                .long("listen_addr")
+                .help("Address to listen on")
+                .takes_value(true)
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("server_addr")
+                .long("server_addr")
+                .help("Address to proxy to")
+                .takes_value(false)
+                .required(false),
+        )
+        .get_matches();
+
+    set_global_default(&matches)?;
+
+    let listen_addr = matches.value_of("listen_addr").unwrap_or("127.0.0.1:8081");
     let listen_addr = listen_addr.parse::<SocketAddr>()?;
 
-    let server_addr = env::args()
-        .nth(2)
-        .unwrap_or_else(|| "127.0.0.1:3000".to_string());
+    let server_addr = matches.value_of("server_addr").unwrap_or("127.0.0.1:3000");
     let server_addr = server_addr.parse::<SocketAddr>()?;
 
     let mut listener = TcpListener::bind(&listen_addr).await?.incoming();
@@ -131,3 +157,24 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+fn set_global_default(matches: &ArgMatches<'_>) -> Result<(), Box<dyn std::error::Error>> {
+    use tracing_subscriber::{FmtSubscriber, filter::EnvFilter};
+    match value_t!(matches, "log_format", LogFormat).unwrap_or(LogFormat::Plain) {
+        LogFormat::Json => {
+            let subscriber = FmtSubscriber::builder()
+                .json()
+                .with_env_filter(EnvFilter::from_default_env().add_directive("proxy_server=trace".parse()?))
+                .finish();
+            tracing::subscriber::set_global_default(subscriber)?;
+        }
+        LogFormat::Plain => {
+            let subscriber = FmtSubscriber::builder()
+                .with_env_filter(EnvFilter::from_default_env().add_directive("proxy_server=trace".parse()?))
+                .finish();
+            tracing::subscriber::set_global_default(subscriber)?;
+        }
+    }
+    Ok(())
+}
+

tracing-serde/src/fields.rs

@@ -0,0 +1,55 @@
+//! Support for serializing fields as `serde` structs or maps.
+use super::*;
+
+#[derive(Debug)]
+pub struct SerializeFieldMap<'a, T>(&'a T);
+
+pub trait AsMap: Sized + sealed::Sealed {
+    fn field_map(&self) -> SerializeFieldMap<Self> {
+        SerializeFieldMap(self)
+    }
+}
+
+impl<'a> AsMap for Event<'a> {}
+impl<'a> AsMap for Attributes<'a> {}
+impl<'a> AsMap for Record<'a> {}
+
+// === impl SerializeFieldMap ===
+
+impl<'a> Serialize for SerializeFieldMap<'a, Event<'_>> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let len = self.0.metadata().fields().len();
+        let serializer = serializer.serialize_map(Some(len))?;
+        let mut visitor = SerdeMapVisitor::new(serializer);
+        self.0.record(&mut visitor);
+        visitor.finish()
+    }
+}
+
+impl<'a> Serialize for SerializeFieldMap<'a, Attributes<'_>> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let len = self.0.metadata().fields().len();
+        let serializer = serializer.serialize_map(Some(len))?;
+        let mut visitor = SerdeMapVisitor::new(serializer);
+        self.0.record(&mut visitor);
+        visitor.finish()
+    }
+}
+
+impl<'a> Serialize for SerializeFieldMap<'a, Record<'_>> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let serializer = serializer.serialize_map(None)?;
+        let mut visitor = SerdeMapVisitor::new(serializer);
+        self.0.record(&mut visitor);
+        visitor.finish()
+    }
+}

tracing-serde/src/lib.rs

@@ -15,6 +15,8 @@ use tracing_core::{
     span::{Attributes, Id, Record},
 };
 
+pub mod fields;
+
 #[derive(Debug)]
 pub struct SerializeField(Field);
 
@@ -156,10 +158,7 @@ impl<'a> Serialize for SerializeRecord<'a> {
         S: Serializer,
     {
         let serializer = serializer.serialize_map(None)?;
-        let mut visitor = SerdeMapVisitor {
-            serializer,
-            state: Ok(()),
-        };
+        let mut visitor = SerdeMapVisitor::new(serializer);
         self.0.record(&mut visitor);
         visitor.finish()
     }
@@ -170,6 +169,18 @@ struct SerdeMapVisitor<S: SerializeMap> {
     state: Result<(), S::Error>,
 }
 
+impl<S> SerdeMapVisitor<S>
+where
+    S: SerializeMap,
+{
+    fn new(serializer: S) -> Self {
+        Self {
+            serializer,
+            state: Ok(()),
+        }
+    }
+}
+
 impl<S> Visit for SerdeMapVisitor<S>
 where
     S: SerializeMap,
@@ -320,12 +331,22 @@ impl<'a> AsSerde<'a> for tracing_core::span::Record<'a> {
     }
 }
 
+impl<'a> AsSerde<'a> for Level {
+    type Serializable = SerializeLevel<'a>;
+
+    fn as_serde(&'a self) -> Self::Serializable {
+        SerializeLevel(self)
+    }
+}
+
 impl<'a> self::sealed::Sealed for Event<'a> {}
 
 impl<'a> self::sealed::Sealed for Attributes<'a> {}
 
 impl self::sealed::Sealed for Id {}
 
+impl self::sealed::Sealed for Level {}
+
 impl<'a> self::sealed::Sealed for Record<'a> {}
 
 impl<'a> self::sealed::Sealed for Metadata<'a> {}

tracing-subscriber/Cargo.toml

@@ -25,6 +25,7 @@ env-filter = ["matchers", "regex", "lazy_static"]
 fmt = ["owning_ref"]
 ansi = ["fmt", "ansi_term"]
 registry_unstable = []
+json = ["tracing-serde", "serde", "serde_json"]
 
 # Alias for `env-filter`; renamed in version 0.1.2, and will be removed in 0.2.
 filter = ["env-filter"]
@@ -44,6 +45,11 @@ ansi_term = { version = "0.11", optional = true }
 owning_ref = { version = "0.4.0", optional = true }
 chrono = { version = "0.4", optional = true }
 
+# only required by the json feature
+serde_json = { version = "1.0", optional = true }
+serde = { version = "1.0", optional = true }
+tracing-serde = { path = "../tracing-serde", optional = true }
+
 # opt-in deps
 parking_lot = { version = ">= 0.7, < 0.10", features = ["owning_ref"], optional = true }