Add plugin usage telemetry (#14531)

adding metrics including: 
* plugin used
* plugin installed/uninstalled
* plugin enabled/disabled

codex-rs/core/src/plugins/manager.rs

@@ -19,6 +19,7 @@ use super::store::PluginInstallResult as StorePluginInstallResult;
 use super::store::PluginStore;
 use super::store::PluginStoreError;
 use super::sync_openai_plugins_repo;
+use crate::analytics_client::AnalyticsEventsClient;
 use crate::auth::CodexAuth;
 use crate::config::Config;
 use crate::config::ConfigService;
@@ -160,6 +161,21 @@ pub struct PluginCapabilitySummary {
     pub app_connector_ids: Vec<AppConnectorId>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginTelemetryMetadata {
+    pub plugin_id: PluginId,
+    pub capability_summary: Option<PluginCapabilitySummary>,
+}
+
+impl PluginTelemetryMetadata {
+    pub fn from_plugin_id(plugin_id: &PluginId) -> Self {
+        Self {
+            plugin_id: plugin_id.clone(),
+            capability_summary: None,
+        }
+    }
+}
+
 impl PluginCapabilitySummary {
     fn from_plugin(plugin: &LoadedPlugin) -> Option<Self> {
         if !plugin.is_active() {
@@ -186,6 +202,15 @@ impl PluginCapabilitySummary {
             || !summary.app_connector_ids.is_empty())
         .then_some(summary)
     }
+
+    pub fn telemetry_metadata(&self) -> Option<PluginTelemetryMetadata> {
+        PluginId::parse(&self.config_name)
+            .ok()
+            .map(|plugin_id| PluginTelemetryMetadata {
+                plugin_id,
+                capability_summary: Some(self.clone()),
+            })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -369,6 +394,7 @@ pub struct PluginsManager {
     codex_home: PathBuf,
     store: PluginStore,
     cache_by_cwd: RwLock<HashMap<PathBuf, PluginLoadOutcome>>,
+    analytics_events_client: RwLock<Option<AnalyticsEventsClient>>,
 }
 
 impl PluginsManager {
@@ -377,9 +403,18 @@ impl PluginsManager {
             codex_home: codex_home.clone(),
             store: PluginStore::new(codex_home),
             cache_by_cwd: RwLock::new(HashMap::new()),
+            analytics_events_client: RwLock::new(None),
         }
     }
 
+    pub fn set_analytics_events_client(&self, analytics_events_client: AnalyticsEventsClient) {
+        let mut stored_client = match self.analytics_events_client.write() {
+            Ok(client_guard) => client_guard,
+            Err(err) => err.into_inner(),
+        };
+        *stored_client = Some(analytics_events_client);
+    }
+
     pub fn plugins_for_config(&self, config: &Config) -> PluginLoadOutcome {
         self.plugins_for_layer_stack(&config.cwd, &config.config_layer_stack, false)
     }
@@ -466,6 +501,17 @@ impl PluginsManager {
             .map(|_| ())
             .map_err(PluginInstallError::from)?;
 
+        let analytics_events_client = match self.analytics_events_client.read() {
+            Ok(client) => client.clone(),
+            Err(err) => err.into_inner().clone(),
+        };
+        if let Some(analytics_events_client) = analytics_events_client {
+            analytics_events_client.track_plugin_installed(plugin_telemetry_metadata_from_root(
+                &result.plugin_id,
+                result.installed_path.as_path(),
+            ));
+        }
+
         Ok(PluginInstallOutcome {
             plugin_id: result.plugin_id,
             plugin_version: result.plugin_version,
@@ -476,6 +522,10 @@ impl PluginsManager {
 
     pub async fn uninstall_plugin(&self, plugin_id: String) -> Result<(), PluginUninstallError> {
         let plugin_id = PluginId::parse(&plugin_id)?;
+        let plugin_telemetry = self
+            .store
+            .active_plugin_root(&plugin_id)
+            .map(|_| installed_plugin_telemetry_metadata(self.codex_home.as_path(), &plugin_id));
         let store = self.store.clone();
         let plugin_id_for_store = plugin_id.clone();
         tokio::task::spawn_blocking(move || store.uninstall(&plugin_id_for_store))
@@ -489,6 +539,16 @@ impl PluginsManager {
             .apply()
             .await?;
 
+        let analytics_events_client = match self.analytics_events_client.read() {
+            Ok(client) => client.clone(),
+            Err(err) => err.into_inner().clone(),
+        };
+        if let Some(plugin_telemetry) = plugin_telemetry
+            && let Some(analytics_events_client) = analytics_events_client
+        {
+            analytics_events_client.track_plugin_uninstalled(plugin_telemetry);
+        }
+
         Ok(())
     }
 
@@ -1360,6 +1420,52 @@ fn load_apps_from_paths(
     connector_ids
 }
 
+pub fn plugin_telemetry_metadata_from_root(
+    plugin_id: &PluginId,
+    plugin_root: &Path,
+) -> PluginTelemetryMetadata {
+    let Some(manifest) = load_plugin_manifest(plugin_root) else {
+        return PluginTelemetryMetadata::from_plugin_id(plugin_id);
+    };
+
+    let manifest_paths = plugin_manifest_paths(&manifest, plugin_root);
+    let has_skills = !plugin_skill_roots(plugin_root, &manifest_paths).is_empty();
+    let mut mcp_server_names = Vec::new();
+    for path in plugin_mcp_config_paths(plugin_root, &manifest_paths) {
+        mcp_server_names.extend(
+            load_mcp_servers_from_file(plugin_root, &path)
+                .mcp_servers
+                .into_keys(),
+        );
+    }
+    mcp_server_names.sort_unstable();
+    mcp_server_names.dedup();
+
+    PluginTelemetryMetadata {
+        plugin_id: plugin_id.clone(),
+        capability_summary: Some(PluginCapabilitySummary {
+            config_name: plugin_id.as_key(),
+            display_name: plugin_id.plugin_name.clone(),
+            description: None,
+            has_skills,
+            mcp_server_names,
+            app_connector_ids: load_plugin_apps(plugin_root),
+        }),
+    }
+}
+
+pub fn installed_plugin_telemetry_metadata(
+    codex_home: &Path,
+    plugin_id: &PluginId,
+) -> PluginTelemetryMetadata {
+    let store = PluginStore::new(codex_home.to_path_buf());
+    let Some(plugin_root) = store.active_plugin_root(plugin_id) else {
+        return PluginTelemetryMetadata::from_plugin_id(plugin_id);
+    };
+
+    plugin_telemetry_metadata_from_root(plugin_id, plugin_root.as_path())
+}
+
 fn load_mcp_servers_from_file(
     plugin_root: &Path,
     mcp_config_path: &AbsolutePathBuf,

codex-rs/core/src/plugins/manager_tests.rs

@@ -226,6 +226,50 @@ fn load_plugins_loads_default_skills_and_mcp_servers() {
     );
 }
 
+#[test]
+fn plugin_telemetry_metadata_uses_default_mcp_config_path() {
+    let codex_home = TempDir::new().unwrap();
+    let plugin_root = codex_home
+        .path()
+        .join("plugins/cache")
+        .join("test/sample/local");
+
+    write_file(
+        &plugin_root.join(".codex-plugin/plugin.json"),
+        r#"{
+  "name": "sample"
+}"#,
+    );
+    write_file(
+        &plugin_root.join(".mcp.json"),
+        r#"{
+  "mcpServers": {
+    "sample": {
+      "type": "http",
+      "url": "https://sample.example/mcp"
+    }
+  }
+}"#,
+    );
+
+    let metadata = plugin_telemetry_metadata_from_root(
+        &PluginId::parse("sample@test").expect("plugin id should parse"),
+        &plugin_root,
+    );
+
+    assert_eq!(
+        metadata.capability_summary,
+        Some(PluginCapabilitySummary {
+            config_name: "sample@test".to_string(),
+            display_name: "sample".to_string(),
+            description: None,
+            has_skills: false,
+            mcp_server_names: vec!["sample".to_string()],
+            app_connector_ids: Vec::new(),
+        })
+    );
+}
+
 #[test]
 fn load_plugins_uses_manifest_configured_component_paths() {
     let codex_home = TempDir::new().unwrap();

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

@@ -5,6 +5,7 @@ mod manifest;
 mod marketplace;
 mod render;
 mod store;
+mod toggles;
 
 pub(crate) use curated_repo::curated_plugins_repo_path;
 pub(crate) use curated_repo::read_curated_plugins_sha;
@@ -23,11 +24,14 @@ pub use manager::PluginLoadOutcome;
 pub use manager::PluginReadOutcome;
 pub use manager::PluginReadRequest;
 pub use manager::PluginRemoteSyncError;
+pub use manager::PluginTelemetryMetadata;
 pub use manager::PluginUninstallError;
 pub use manager::PluginsManager;
 pub use manager::RemotePluginSyncResult;
+pub use manager::installed_plugin_telemetry_metadata;
 pub use manager::load_plugin_apps;
 pub(crate) use manager::plugin_namespace_for_skill_path;
+pub use manager::plugin_telemetry_metadata_from_root;
 pub use manifest::PluginManifestInterfaceSummary;
 pub(crate) use manifest::PluginManifestPaths;
 pub(crate) use manifest::load_plugin_manifest;
@@ -41,3 +45,4 @@ pub use marketplace::MarketplacePluginSourceSummary;
 pub(crate) use render::render_explicit_plugin_instructions;
 pub(crate) use render::render_plugins_section;
 pub use store::PluginId;
+pub use toggles::collect_plugin_enabled_candidates;

codex-rs/core/src/plugins/toggles.rs

@@ -0,0 +1,100 @@
+use serde_json::Value as JsonValue;
+use std::collections::BTreeMap;
+
+pub fn collect_plugin_enabled_candidates<'a>(
+    edits: impl Iterator<Item = (&'a String, &'a JsonValue)>,
+) -> BTreeMap<String, bool> {
+    let mut pending_changes = BTreeMap::new();
+    for (key_path, value) in edits {
+        let segments = key_path
+            .split('.')
+            .map(str::to_string)
+            .collect::<Vec<String>>();
+        match segments.as_slice() {
+            [plugins, plugin_id, enabled]
+                if plugins == "plugins" && enabled == "enabled" && value.is_boolean() =>
+            {
+                if let Some(enabled) = value.as_bool() {
+                    pending_changes.insert(plugin_id.clone(), enabled);
+                }
+            }
+            [plugins, plugin_id] if plugins == "plugins" => {
+                if let Some(enabled) = value.get("enabled").and_then(JsonValue::as_bool) {
+                    pending_changes.insert(plugin_id.clone(), enabled);
+                }
+            }
+            [plugins] if plugins == "plugins" => {
+                let Some(entries) = value.as_object() else {
+                    continue;
+                };
+                for (plugin_id, plugin_value) in entries {
+                    let Some(enabled) = plugin_value.get("enabled").and_then(JsonValue::as_bool)
+                    else {
+                        continue;
+                    };
+                    pending_changes.insert(plugin_id.clone(), enabled);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pending_changes
+}
+
+#[cfg(test)]
+mod tests {
+    use super::collect_plugin_enabled_candidates;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn collect_plugin_enabled_candidates_tracks_direct_and_table_writes() {
+        let candidates = collect_plugin_enabled_candidates(
+            [
+                (&"plugins.sample@test.enabled".to_string(), &json!(true)),
+                (
+                    &"plugins.other@test".to_string(),
+                    &json!({ "enabled": false, "ignored": true }),
+                ),
+                (
+                    &"plugins".to_string(),
+                    &json!({
+                        "nested@test": { "enabled": true },
+                        "skip@test": { "name": "skip" },
+                    }),
+                ),
+            ]
+            .into_iter(),
+        );
+
+        assert_eq!(
+            candidates,
+            BTreeMap::from([
+                ("nested@test".to_string(), true),
+                ("other@test".to_string(), false),
+                ("sample@test".to_string(), true),
+            ])
+        );
+    }
+
+    #[test]
+    fn collect_plugin_enabled_candidates_uses_last_write_for_same_plugin() {
+        let candidates = collect_plugin_enabled_candidates(
+            [
+                (&"plugins.sample@test.enabled".to_string(), &json!(true)),
+                (
+                    &"plugins.sample@test".to_string(),
+                    &json!({ "enabled": false }),
+                ),
+            ]
+            .into_iter(),
+        );
+
+        assert_eq!(
+            candidates,
+            BTreeMap::from([("sample@test".to_string(), false)])
+        );
+    }
+}