feat(observability): wire file logging + run_id correlation + startup banner

Phase G of v0.1.0 hardening (parallel-code-review items 6, 16):

- feat(analytics): attach `RollingFileAppender` (daily rotation,
  JSON, INFO+) to the `Registry` alongside console and OTLP layers.
  Previously the file layer existed in
  `observability::logging::init_minimal_logging` but that function
  was never invoked from main.rs, so `~/.jarvy/logs/jarvy.log` was
  always empty and `jarvy ticket create` shipped a hollow log file
  to support. One subscriber now owns all sinks (review #1).

- feat(analytics): drop hard-coded `LevelFilter::ERROR` on the OTLP
  bridge; default to `info`, override via `JARVY_OTLP_LEVEL`.
  `tool.installed`, `setup.inventory`, `hook.completed` events
  actually export now (review #2).

- feat(setup_cmd): generate per-invocation `run_id` (uuid v7) and
  hold an `info_span!("setup", run_id)` for the entire `run_setup`
  call. Every event in the file log / OTLP backend now carries
  `run_id` so support can stitch parallel install threads back
  together (review #6).

- feat(setup_cmd): emit `setup.start` event with version, os, arch,
  config_source (local/remote), config_path, ci_provider, jobs,
  dry_run — the first five questions support asks. Was buried in
  scattered `eprintln!`s before (review #11).

- feat(setup_cmd): rayon worker threads re-enter the parent setup
  span via `parent_span.enter()` inside `pool.install`. Without
  this, every event from a parallel-install worker was
  span-orphaned in traces (review #7). Each tool gets its own
  `install_tool` span keyed by name+version.

Outstanding from item 6 (deferred):
- Extending `tool_failed`/`hook_failed` signature with
  pm/exit_code/stderr_redacted/os fields (touches every caller).
- Promoting these from warn to error.

Outstanding from item 16 (deferred):
- Reconciling `duration_ms` event field vs `with_unit("s")`
  histogram to one canonical unit (touches ~5 telemetry events
  and any consuming dashboards).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Cliftonz

src/analytics.rs

@@ -9,8 +9,10 @@
 use std::env;
 use std::io::Write;
 use tracing::Level;
+use tracing_appender::rolling::{RollingFileAppender, Rotation};
 use tracing_subscriber::Layer;
 use tracing_subscriber::filter::{FilterFn, LevelFilter};
+use tracing_subscriber::fmt::format::FmtSpan;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::registry::Registry;
 
@@ -57,15 +59,51 @@ pub fn init_logging(enable_analytics: bool) {
         .with_writer(std::io::stderr)
         .with_filter(LevelFilter::ERROR);
 
-    // Only if analytics enabled, export errors to OTLP logs
+    // File layer at ~/.jarvy/logs/jarvy.log (daily rotation, JSON).
+    //
+    // Previously the file layer existed in `observability::logging::init_*`
+    // but those functions were never called from `main.rs` — so
+    // `~/.jarvy/logs/jarvy.log` was always empty, `jarvy logs view` returned
+    // nothing, and `jarvy ticket create` shipped a hollow log file to support.
+    // Wire it into the same `Registry` as the console + OTLP layers so a
+    // single `set_global_default` covers all sinks (observability review #1).
+    let file_layer = match ensure_log_dir() {
+        Ok(dir) => {
+            let appender = RollingFileAppender::new(Rotation::DAILY, dir, "jarvy.log");
+            let layer = tracing_subscriber::fmt::layer()
+                .json()
+                .with_writer(appender)
+                .with_span_events(FmtSpan::CLOSE)
+                .with_current_span(true)
+                .with_target(true)
+                .with_ansi(false)
+                // Capture every level the user might care about during a
+                // failed `jarvy setup`. Cheaper than rebuilding telemetry
+                // from `eprintln!` after the fact.
+                .with_filter(LevelFilter::INFO);
+            Some(layer)
+        }
+        Err(e) => {
+            eprintln!("Warning: file logging disabled — could not create log dir: {e}");
+            None
+        }
+    };
+
+    // Only if analytics enabled, export to OTLP logs.
+    //
+    // Filter is now driven by `JARVY_OTLP_LEVEL` (default `info`) instead of
+    // the previous hard-coded `LevelFilter::ERROR`. The old filter dropped
+    // every `info!`-level event — `tool.installed`, `setup.inventory`,
+    // `hook.completed` — so `logs = true` in TelemetryConfig was a lie at
+    // export time (observability review #2).
     let mut bootstrap_error: Option<String> = None;
     let otel_layer_opt = if enable_analytics {
         match build_otlp_logger_provider() {
             Ok(logger_provider) => {
                 let layer = opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge::new(
                     &logger_provider,
                 )
-                .with_filter(LevelFilter::ERROR); // export only errors to OTEL
+                .with_filter(otlp_level_filter());
                 Some(layer)
             }
             Err(e) => {
@@ -85,6 +123,7 @@ pub fn init_logging(enable_analytics: bool) {
     let subscriber = Registry::default()
         .with(stdout_non_error)
         .with(stderr_errors)
+        .with(file_layer)
         .with(otel_layer_opt);
 
     let install_result = tracing::subscriber::set_global_default(subscriber);
@@ -108,6 +147,34 @@ pub fn init_logging(enable_analytics: bool) {
     }
 }
 
+/// Resolve the OTLP-bridge level filter. `JARVY_OTLP_LEVEL` (or the legacy
+/// `JARVY_OTLP_LOGS` boolean) overrides the default `info`. Setting it to
+/// `error` recovers the old behavior for users who explicitly want quiet
+/// exports.
+fn otlp_level_filter() -> LevelFilter {
+    match env::var("JARVY_OTLP_LEVEL")
+        .map(|v| v.trim().to_ascii_lowercase())
+        .as_deref()
+    {
+        Ok("error") => LevelFilter::ERROR,
+        Ok("warn") => LevelFilter::WARN,
+        Ok("info") => LevelFilter::INFO,
+        Ok("debug") => LevelFilter::DEBUG,
+        Ok("trace") => LevelFilter::TRACE,
+        _ => LevelFilter::INFO,
+    }
+}
+
+/// Returns `~/.jarvy/logs`, creating it if necessary.
+fn ensure_log_dir() -> std::io::Result<std::path::PathBuf> {
+    let dir = dirs::home_dir()
+        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "no home directory"))?
+        .join(".jarvy")
+        .join("logs");
+    std::fs::create_dir_all(&dir)?;
+    Ok(dir)
+}
+
 fn otlp_logs_endpoint() -> String {
     if let Ok(v) = env::var("JARVY_OTLP_LOGS_ENDPOINT") {
         if !v.trim().is_empty() {

src/commands/setup_cmd.rs

@@ -89,6 +89,34 @@ pub fn run_setup(
         file.to_string()
     };
 
+    // Generate a per-invocation correlation ID. Every event emitted from
+    // this `run_setup` call carries `run_id` so support can stitch parallel
+    // install threads back together when reading `~/.jarvy/logs/jarvy.log`
+    // or an OTLP backend (observability review #6, #7).
+    let run_id = uuid::Uuid::now_v7();
+    // Hold this span open for the entire setup so `tracing::info_span!`
+    // child spans inherit `run_id` automatically.
+    let setup_span = tracing::info_span!("setup", run_id = %run_id);
+    let _setup_span_guard = setup_span.enter();
+
+    // Startup banner — the first five questions support asks ("what
+    // version, what OS, what package manager, what config source, what CI
+    // provider"). Without this the only signal in a ticket bundle is
+    // `eprintln!`s scattered through the install loop (observability
+    // review #11).
+    tracing::info!(
+        event = "setup.start",
+        run_id = %run_id,
+        version = env!("CARGO_PKG_VERSION"),
+        os = std::env::consts::OS,
+        arch = std::env::consts::ARCH,
+        config_source = %if from.is_some() { "remote" } else { "local" },
+        config_path = %config_path,
+        ci_provider = ?ci_env.as_ref().map(|e| e.provider.to_string()),
+        jobs = parallel_jobs,
+        dry_run = dry_run,
+    );
+
     let config = Config::new_with_workspace(&config_path);
     let hooks_config = config.get_hooks();
     let hook_settings = HookConfig::from(&hooks_config.config);
@@ -318,11 +346,25 @@ pub fn run_setup(
                 let error_collector: Arc<Mutex<Vec<(String, String, String)>>> =
                     Arc::new(Mutex::new(Vec::new()));
 
+                // Capture the parent span (which carries `run_id`) so rayon
+                // worker threads — which have their own thread-local span
+                // stack — can re-enter it. Without this, every event emitted
+                // from a parallel-install worker is span-orphaned in
+                // `~/.jarvy/logs/jarvy.log` and OTLP traces (observability
+                // review #7).
+                let parent_span = tracing::Span::current();
                 pool.install(|| {
                     tool_groups
                         .custom_install
                         .par_iter()
                         .for_each(|(name, version)| {
+                            let _g = parent_span.enter();
+                            let install_span = tracing::info_span!(
+                                "install_tool",
+                                tool = %name,
+                                version = %version,
+                            );
+                            let _is = install_span.enter();
                             println!(
                                 "Installing {} version {} using custom installer",
                                 name, version