Fix hook run analytics source classification

Author: abhinav-oai

codex-rs/Cargo.lock

@@ -18,7 +18,6 @@ codex-git-utils = { workspace = true }
 codex-login = { workspace = true }
 codex-plugin = { workspace = true }
 codex-protocol = { workspace = true }
-dirs = { workspace = true }
 os_info = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }

codex-rs/analytics/Cargo.toml

@@ -23,6 +23,7 @@ use crate::facts::AppInvocation;
 use crate::facts::AppMentionedInput;
 use crate::facts::AppUsedInput;
 use crate::facts::CodexCompactionEvent;
+use crate::facts::CodexHookSource;
 use crate::facts::CompactionImplementation;
 use crate::facts::CompactionPhase;
 use crate::facts::CompactionReason;
@@ -1290,8 +1291,6 @@ fn plugin_management_event_serializes_expected_shape() {
 
 #[test]
 fn hook_run_event_serializes_expected_shape() {
-    let home = dirs::home_dir().expect("home dir should be available for analytics tests");
-
     let tracking = TrackEventsContext {
         model_slug: "gpt-5".to_string(),
         thread_id: "thread-3".to_string(),
@@ -1303,10 +1302,8 @@ fn hook_run_event_serializes_expected_shape() {
             &tracking,
             HookRunFact {
                 event_name: HookEventName::PreToolUse,
-                source_path: PathBuf::from(&home).join(".codex/hooks.json"),
-                cwd: PathBuf::from(&home).join("worktree"),
+                hook_source: CodexHookSource::User,
                 status: HookRunStatus::Completed,
-                duration_ms: Some(42),
             },
         ),
     });
@@ -1331,7 +1328,6 @@ fn hook_run_event_serializes_expected_shape() {
 
 #[test]
 fn hook_run_metadata_maps_sources_and_statuses() {
-    let home = dirs::home_dir().expect("home dir should be available for analytics tests");
     let tracking = TrackEventsContext {
         model_slug: "gpt-5".to_string(),
         thread_id: "thread-1".to_string(),
@@ -1342,32 +1338,26 @@ fn hook_run_metadata_maps_sources_and_statuses() {
         &tracking,
         HookRunFact {
             event_name: HookEventName::SessionStart,
-            source_path: PathBuf::from("/etc/codex/hooks.json"),
-            cwd: PathBuf::from(&home).join("worktree"),
+            hook_source: CodexHookSource::System,
             status: HookRunStatus::Completed,
-            duration_ms: None,
         },
     ))
     .expect("serialize system hook");
     let project = serde_json::to_value(codex_hook_run_metadata(
         &tracking,
         HookRunFact {
             event_name: HookEventName::Stop,
-            source_path: PathBuf::from(&home).join("worktree/.codex/hooks.json"),
-            cwd: PathBuf::from(&home).join("worktree/src"),
+            hook_source: CodexHookSource::Project,
             status: HookRunStatus::Blocked,
-            duration_ms: None,
         },
     ))
     .expect("serialize project hook");
     let unknown = serde_json::to_value(codex_hook_run_metadata(
         &tracking,
         HookRunFact {
             event_name: HookEventName::UserPromptSubmit,
-            source_path: PathBuf::from("/tmp/hooks.json"),
-            cwd: PathBuf::from(&home).join("worktree"),
+            hook_source: CodexHookSource::Unknown,
             status: HookRunStatus::Failed,
-            duration_ms: None,
         },
     ))
     .expect("serialize unknown hook");
@@ -1382,7 +1372,6 @@ fn hook_run_metadata_maps_sources_and_statuses() {
 
 #[test]
 fn hook_run_metadata_maps_stopped_status() {
-    let home = dirs::home_dir().expect("home dir should be available for analytics tests");
     let tracking = TrackEventsContext {
         model_slug: "gpt-5".to_string(),
         thread_id: "thread-1".to_string(),
@@ -1393,10 +1382,8 @@ fn hook_run_metadata_maps_stopped_status() {
         &tracking,
         HookRunFact {
             event_name: HookEventName::Stop,
-            source_path: home.join(".codex/hooks.json"),
-            cwd: home.join("worktree"),
+            hook_source: CodexHookSource::User,
             status: HookRunStatus::Stopped,
-            duration_ms: None,
         },
     ))
     .expect("serialize stopped hook");
@@ -1497,10 +1484,8 @@ async fn reducer_ingests_hook_run_fact() {
                 },
                 hook: HookRunFact {
                     event_name: HookEventName::PostToolUse,
-                    source_path: PathBuf::from("/tmp/hooks.json"),
-                    cwd: PathBuf::from("/tmp/project"),
+                    hook_source: CodexHookSource::Unknown,
                     status: HookRunStatus::Failed,
-                    duration_ms: Some(7),
                 },
             })),
             &mut events,

codex-rs/analytics/src/analytics_client_tests.rs

@@ -1,5 +1,6 @@
 use crate::facts::AppInvocation;
 use crate::facts::CodexCompactionEvent;
+use crate::facts::CodexHookSource;
 use crate::facts::HookRunFact;
 use crate::facts::InvocationType;
 use crate::facts::PluginState;
@@ -20,7 +21,6 @@ use codex_protocol::protocol::HookEventName;
 use codex_protocol::protocol::HookRunStatus;
 use codex_protocol::protocol::SubAgentSource;
 use serde::Serialize;
-use std::path::Path;
 
 #[derive(Clone, Copy, Debug, Serialize)]
 #[serde(rename_all = "snake_case")]
@@ -305,15 +305,6 @@ pub(crate) struct CodexAppUsedEventRequest {
     pub(crate) event_params: CodexAppMetadata,
 }
 
-#[derive(Clone, Copy, Debug, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub(crate) enum CodexHookSource {
-    System,
-    User,
-    Project,
-    Unknown,
-}
-
 #[derive(Serialize)]
 pub(crate) struct CodexHookRunMetadata {
     pub(crate) thread_id: Option<String>,
@@ -568,10 +559,7 @@ pub(crate) fn codex_hook_run_metadata(
         turn_id: Some(tracking.turn_id.clone()),
         model_slug: Some(tracking.model_slug.clone()),
         hook_name: Some(hook.event_name),
-        hook_source: Some(hook_source_for_path(
-            hook.source_path.as_path(),
-            hook.cwd.as_path(),
-        )),
+        hook_source: Some(hook.hook_source),
         status: Some(analytics_hook_status(hook.status)),
     }
 }
@@ -634,31 +622,6 @@ pub(crate) fn subagent_parent_thread_id(subagent_source: &SubAgentSource) -> Opt
     }
 }
 
-fn hook_source_for_path(source_path: &Path, cwd: &Path) -> CodexHookSource {
-    if source_path.starts_with("/etc/codex") {
-        return CodexHookSource::System;
-    }
-
-    let home = dirs::home_dir();
-    if let Some(home) = home
-        && source_path.starts_with(home.join(".codex"))
-    {
-        return CodexHookSource::User;
-    }
-
-    // Project hooks are loaded from a `.codex/hooks.json` rooted at or above the
-    // current working directory, so classify by walking cwd ancestors.
-    if source_path.ends_with(".codex/hooks.json")
-        && cwd
-            .ancestors()
-            .any(|ancestor| source_path.starts_with(ancestor.join(".codex")))
-    {
-        return CodexHookSource::Project;
-    }
-
-    CodexHookSource::Unknown
-}
-
 fn analytics_hook_status(status: HookRunStatus) -> HookRunStatus {
     match status {
         // Running is unexpected here and normalized defensively.

codex-rs/analytics/src/events.rs

@@ -243,6 +243,15 @@ pub enum CompactionStatus {
     Interrupted,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CodexHookSource {
+    System,
+    User,
+    Project,
+    Unknown,
+}
+
 #[derive(Clone)]
 pub struct CodexCompactionEvent {
     pub thread_id: String,
@@ -327,10 +336,8 @@ pub(crate) struct HookRunInput {
 
 pub struct HookRunFact {
     pub event_name: HookEventName,
-    pub source_path: PathBuf,
-    pub cwd: PathBuf,
+    pub hook_source: CodexHookSource,
     pub status: HookRunStatus,
-    pub duration_ms: Option<i64>,
 }
 
 pub(crate) struct PluginUsedInput {

codex-rs/analytics/src/facts.rs

@@ -22,6 +22,7 @@ pub use events::GuardianReviewedAction;
 pub use facts::AnalyticsJsonRpcError;
 pub use facts::AppInvocation;
 pub use facts::CodexCompactionEvent;
+pub use facts::CodexHookSource;
 pub use facts::CodexTurnSteerEvent;
 pub use facts::CompactionImplementation;
 pub use facts::CompactionPhase;

codex-rs/analytics/src/lib.rs

@@ -411,12 +411,12 @@ fn system_requirements_toml_file() -> io::Result<AbsolutePathBuf> {
 }
 
 #[cfg(unix)]
-fn system_config_toml_file() -> io::Result<AbsolutePathBuf> {
+pub(crate) fn system_config_toml_file() -> io::Result<AbsolutePathBuf> {
     AbsolutePathBuf::from_absolute_path(Path::new(SYSTEM_CONFIG_TOML_FILE_UNIX))
 }
 
 #[cfg(windows)]
-fn system_config_toml_file() -> io::Result<AbsolutePathBuf> {
+pub(crate) fn system_config_toml_file() -> io::Result<AbsolutePathBuf> {
     windows_system_config_toml_file()
 }
 

codex-rs/core/src/config_loader/mod.rs

@@ -1,6 +1,8 @@
 use std::future::Future;
+use std::path::Path;
 use std::sync::Arc;
 
+use codex_analytics::CodexHookSource;
 use codex_analytics::HookRunFact;
 use codex_analytics::build_track_events_context;
 use codex_hooks::PostToolUseOutcome;
@@ -24,6 +26,7 @@ use serde_json::Value;
 
 use crate::codex::Session;
 use crate::codex::TurnContext;
+use crate::config_loader::system_config_toml_file;
 use crate::event_mapping::parse_turn_item;
 
 pub(crate) struct HookRuntimeOutcome {
@@ -358,14 +361,41 @@ fn hook_run_analytics_payload(
         ),
         HookRunFact {
             event_name: completed.run.event_name,
-            source_path: completed.run.source_path.to_path_buf(),
-            cwd: turn_context.cwd.to_path_buf(),
+            hook_source: hook_source_for_path(
+                completed.run.source_path.as_path(),
+                turn_context.config.codex_home.as_path(),
+                turn_context.cwd.as_path(),
+            ),
             status: completed.run.status,
-            duration_ms: completed.run.duration_ms,
         },
     )
 }
 
+fn hook_source_for_path(source_path: &Path, codex_home: &Path, cwd: &Path) -> CodexHookSource {
+    if let Ok(system_config_path) = system_config_toml_file()
+        && let Some(system_config_dir) = system_config_path.as_path().parent()
+        && source_path.starts_with(system_config_dir)
+    {
+        return CodexHookSource::System;
+    }
+
+    if source_path.starts_with(codex_home) {
+        return CodexHookSource::User;
+    }
+
+    // Project hooks are loaded from a `.codex/hooks.json` rooted at or above the
+    // current working directory, so classify by walking cwd ancestors.
+    if source_path.ends_with(Path::new(".codex").join("hooks.json"))
+        && cwd
+            .ancestors()
+            .any(|ancestor| source_path.starts_with(ancestor.join(".codex")))
+    {
+        return CodexHookSource::Project;
+    }
+
+    CodexHookSource::Unknown
+}
+
 fn hook_permission_mode(turn_context: &TurnContext) -> String {
     match turn_context.approval_policy.value() {
         AskForApproval::Never => "bypassPermissions",
@@ -379,14 +409,14 @@ fn hook_permission_mode(turn_context: &TurnContext) -> String {
 
 #[cfg(test)]
 mod tests {
+    use codex_analytics::CodexHookSource;
     use codex_protocol::models::ContentItem;
     use codex_protocol::protocol::HookEventName;
     use codex_protocol::protocol::HookExecutionMode;
     use codex_protocol::protocol::HookHandlerType;
     use codex_protocol::protocol::HookRunStatus;
     use codex_protocol::protocol::HookScope;
     use pretty_assertions::assert_eq;
-    use std::path::PathBuf;
 
     use super::additional_context_messages;
     use super::hook_run_analytics_payload;
@@ -445,10 +475,8 @@ mod tests {
         assert_eq!(tracking.turn_id, "turn-from-hook");
         assert_eq!(tracking.model_slug, turn_context.model_info.slug);
         assert_eq!(hook.event_name, HookEventName::Stop);
-        assert_eq!(hook.source_path, PathBuf::from("/tmp/hooks.json"));
-        assert_eq!(hook.cwd, turn_context.cwd.to_path_buf());
+        assert_eq!(hook.hook_source, CodexHookSource::Unknown);
         assert_eq!(hook.status, HookRunStatus::Blocked);
-        assert_eq!(hook.duration_ms, Some(27));
     }
 
     #[tokio::test]
@@ -466,6 +494,53 @@ mod tests {
         assert_eq!(hook.status, HookRunStatus::Failed);
     }
 
+    #[test]
+    fn hook_source_for_path_classifies_user_project_and_unknown() {
+        let codex_home = test_path_buf("/tmp/custom-codex-home").abs();
+        let cwd = test_path_buf("/tmp/worktree/src").abs();
+
+        let system_hooks_path = super::system_config_toml_file()
+            .expect("system config path")
+            .parent()
+            .expect("system config directory")
+            .join("hooks.json");
+
+        assert_eq!(
+            super::hook_source_for_path(
+                system_hooks_path.as_path(),
+                codex_home.as_path(),
+                cwd.as_path(),
+            ),
+            CodexHookSource::System,
+        );
+        assert_eq!(
+            super::hook_source_for_path(
+                codex_home.join("hooks.json").as_path(),
+                codex_home.as_path(),
+                cwd.as_path(),
+            ),
+            CodexHookSource::User,
+        );
+        assert_eq!(
+            super::hook_source_for_path(
+                test_path_buf("/tmp/worktree/.codex/hooks.json")
+                    .abs()
+                    .as_path(),
+                codex_home.as_path(),
+                cwd.as_path(),
+            ),
+            CodexHookSource::Project,
+        );
+        assert_eq!(
+            super::hook_source_for_path(
+                test_path_buf("/tmp/hooks.json").abs().as_path(),
+                codex_home.as_path(),
+                cwd.as_path(),
+            ),
+            CodexHookSource::Unknown,
+        );
+    }
+
     fn sample_hook_run(status: HookRunStatus) -> HookRunSummary {
         HookRunSummary {
             id: "stop:0:/tmp/hooks.json".to_string(),