feat: json log option

Cargo.lock

···
  "quinn-udp",
  "rustc-hash 2.1.1",
  "rustls",
- "socket2 0.5.8",
+ "socket2 0.6.0",
  "thiserror 2.0.12",
  "tokio",
  "tracing",
···
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.5.8",
+ "socket2 0.6.0",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "tracing-serde"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
 name = "tracing-subscriber"
 version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "nu-ansi-term",
  "once_cell",
  "regex",
+ "serde",
+ "serde_json",
  "sharded-slab",
  "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
  "tracing-log",
+ "tracing-serde",
 ]
 
 [[package]]

consumer/Cargo.toml

···
 tokio-tungstenite = { version = "0.26.1", features = ["native-tls"] }
 tokio-util = { version = "0.7.14", features = ["io", "rt"] }
 tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json"] }

consumer/src/config.rs

···
 
 #[derive(Debug, Deserialize)]
 pub struct Config {
+    #[serde(flatten)]
+    pub instruments: ConfigInstruments,
     pub index_uri: String,
     pub database: deadpool_postgres::Config,
     pub redis_uri: String,
···
     pub indexer: Option<IndexerConfig>,
     /// Configuration items specific to backfill
     pub backfill: Option<BackfillConfig>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ConfigInstruments {
+    #[serde(default)]
+    pub log_json: bool,
 }
 
 #[derive(Debug, Deserialize)]

consumer/src/instrumentation.rs

···
+use tracing::Subscriber;
+use tracing_subscriber::filter::Filtered;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::registry::LookupSpan;
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{EnvFilter, Layer};
+
+pub fn init_instruments(cfg: &crate::config::ConfigInstruments) {
+    let log_layer = init_log(cfg.log_json);
+
+    tracing_subscriber::registry().with(log_layer).init();
+}
+
+fn init_log<S>(json: bool) -> Filtered<Box<dyn Layer<S> + Send + Sync>, EnvFilter, S>
+where
+    S: Subscriber + for<'span> LookupSpan<'span>,
+{
+    let stdout_filter = EnvFilter::from_default_env();
+
+    match json {
+        true => tracing_subscriber::fmt::layer().json().boxed(),
+        false => tracing_subscriber::fmt::layer().boxed(),
+    }
+    .with_filter(stdout_filter)
+}

consumer/src/main.rs

···
 mod db;
 mod firehose;
 mod indexer;
+mod instrumentation;
 mod label_indexer;
 mod utils;
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
-    tracing_subscriber::fmt::init();
     PrometheusBuilder::new().install()?;
 
     let cli = cmd::parse();
     let conf = config::load_config()?;
 
+    instrumentation::init_instruments(&conf.instruments);
     let user_agent = build_ua(&conf.ua_contact);
 
     let pool = conf.database.create_pool(Some(Runtime::Tokio1), NoTls)?;

parakeet-index/Cargo.toml

···
 tokio = { version = "1.42.0", features = ["full"], optional = true }
 tonic-health = { version = "0.13.0", optional = true }
 tracing = { version = "0.1.40", optional = true }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"], optional = true }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json"], optional = true }
 tracing-opentelemetry = { version = "0.32", optional = true }
 
 [build-dependencies]

parakeet-index/src/main.rs

···
 async fn main() -> eyre::Result<()> {
     let conf = config::load_config()?;
 
-    instrumentation::init_instruments(conf.otel_enable);
+    instrumentation::init_instruments(&conf.instruments);
 
     let db_root = conf.index_db_path.parse()?;
     let addr = std::net::SocketAddr::new(conf.server.bind_address.parse()?, conf.server.port);
···
     let service = Service::new(state.clone());
 
     let mw = tower::ServiceBuilder::new()
-        .option_layer(conf.otel_enable.then(OtelGrpcLayer::default));
+        .option_layer(conf.instruments.otel_enable.then(OtelGrpcLayer::default));
 
     Server::builder()
         .layer(mw)

parakeet-index/src/server/config.rs

···
 
 #[derive(Debug, Deserialize)]
 pub struct Config {
-    #[serde(default)]
-    pub otel_enable: bool,
+    #[serde(flatten)]
+    pub instruments: ConfigInstruments,
     pub database_url: String,
     pub index_db_path: String,
     #[serde(default)]
     pub server: ConfigServer,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ConfigInstruments {
+    #[serde(default)]
+    pub otel_enable: bool,
+    #[serde(default)]
+    pub log_json: bool,
 }
 
 #[derive(Debug, Deserialize)]

parakeet-index/src/server/instrumentation.rs

···
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{EnvFilter, Layer};
 
-pub fn init_instruments(otel_enable: bool) {
-    let otel_layer = otel_enable.then(init_otel);
-
-    let stdout_filter =
-        EnvFilter::from_default_env().add_directive("otel::tracing=off".parse().unwrap());
+pub fn init_instruments(cfg: &super::config::ConfigInstruments) {
+    let otel_layer = cfg.otel_enable.then(init_otel);
+    let log_layer = init_log(cfg.log_json);
 
     tracing_subscriber::registry()
-        .with(tracing_subscriber::fmt::layer().with_filter(stdout_filter))
+        .with(log_layer)
         .with(otel_layer)
         .init();
 }
···
 
     OpenTelemetryLayer::new(tracer).with_filter(otel_filter)
 }
+
+fn init_log<S>(json: bool) -> Filtered<Box<dyn Layer<S> + Send + Sync>, EnvFilter, S>
+where
+    S: Subscriber + for<'span> LookupSpan<'span>,
+{
+    let stdout_filter =
+        EnvFilter::from_default_env().add_directive("otel::tracing=off".parse().unwrap());
+
+    match json {
+        true => tracing_subscriber::fmt::layer().json().boxed(),
+        false => tracing_subscriber::fmt::layer().boxed(),
+    }
+        .with_filter(stdout_filter)
+}

parakeet/Cargo.toml

···
 tower = "0.5"
 tower-http = { version = "0.6.2", features = ["cors", "trace"] }
 tracing = "0.1.40"
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json"] }
 tracing-opentelemetry = "0.32"

parakeet/src/config.rs

···
 
 #[derive(Debug, Deserialize)]
 pub struct Config {
-    #[serde(default)]
-    pub otel_enable: bool,
+    #[serde(flatten)]
+    pub instruments: ConfigInstruments,
     pub index_uri: String,
     pub database_url: String,
     pub redis_uri: String,
···
     pub did_allowlist: Option<Vec<String>>,
     #[serde(default)]
     pub migrate: bool,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ConfigInstruments {
+    #[serde(default)]
+    pub otel_enable: bool,
+    #[serde(default)]
+    pub log_json: bool,
 }
 
 #[derive(Debug, Deserialize)]

parakeet/src/instrumentation.rs

···
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{EnvFilter, Layer};
 
-pub fn init_instruments(otel_enable: bool) {
-    let otel_layer = otel_enable.then(init_otel);
-
-    let stdout_filter =
-        EnvFilter::from_default_env().add_directive("otel::tracing=off".parse().unwrap());
+pub fn init_instruments(cfg: &crate::config::ConfigInstruments) {
+    let otel_layer = cfg.otel_enable.then(init_otel);
+    let log_layer = init_log(cfg.log_json);
 
     tracing_subscriber::registry()
-        .with(tracing_subscriber::fmt::layer().with_filter(stdout_filter))
+        .with(log_layer)
         .with(otel_layer)
         .init();
 }
···
 
     OpenTelemetryLayer::new(tracer).with_filter(otel_filter)
 }
+
+fn init_log<S>(json: bool) -> Filtered<Box<dyn Layer<S> + Send + Sync>, EnvFilter, S>
+where
+    S: Subscriber + for<'span> LookupSpan<'span>,
+{
+    let stdout_filter =
+        EnvFilter::from_default_env().add_directive("otel::tracing=off".parse().unwrap());
+
+    match json {
+        true => tracing_subscriber::fmt::layer().json().boxed(),
+        false => tracing_subscriber::fmt::layer().boxed(),
+    }
+    .with_filter(stdout_filter)
+}

parakeet/src/main.rs

···
 async fn main() -> eyre::Result<()> {
     let conf = config::load_config()?;
 
-    instrumentation::init_instruments(conf.otel_enable);
+    instrumentation::init_instruments(&conf.instruments);
 
     let db_mgr = AsyncDieselConnectionManager::<AsyncPgConnection>::new(&conf.database_url);
     let pool = Pool::builder(db_mgr).build()?;
···
     let did_doc = did_web_doc(&conf.service);
 
     let mw = tower::ServiceBuilder::new()
-        .option_layer(conf.otel_enable.then(OtelInResponseLayer::default))
-        .option_layer(conf.otel_enable.then(OtelAxumLayer::default))
+        .option_layer(conf.instruments.otel_enable.then(OtelInResponseLayer::default))
+        .option_layer(conf.instruments.otel_enable.then(OtelAxumLayer::default))
         .layer(TraceLayer::new_for_http())
         .layer(cors);