openai/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-11-02 19:43:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

event definitions

Browse Source
This commit is contained in:
Roy Han
2026-03-24 17:28:06 -07:00
parent 8a6be13ae6
commit 694ff84ec1
4 changed files with 163 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/core/src/analytics_client.rs
+112 -115
View File
@@ -55,6 +55,13 @@ pub(crate) enum TurnType {
PromptQueued,
}
#[derive(Clone, Copy, Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub(crate) enum TurnEventType {
Start,
Steer,
}
#[derive(Clone, Copy)]
pub(crate) struct UserMessageMetadata {
pub(crate) user_message_type: UserMessageType,
@@ -121,11 +128,11 @@ impl AnalyticsEventsQueue {
TrackEventsJob::AppUsed(job) => {
send_track_app_used(&auth_manager, job).await;
}
TrackEventsJob::TurnMetadata(job) => {
send_track_turn_metadata(&auth_manager, job).await;
TrackEventsJob::TurnStart(job) => {
send_track_turn_start(&auth_manager, job).await;
}
TrackEventsJob::InputMessageMetadata(job) => {
send_track_input_message_metadata(&auth_manager, job).await;
TrackEventsJob::TurnSteer(job) => {
send_track_turn_steer(&auth_manager, job).await;
}
TrackEventsJob::PluginUsed(job) => {
send_track_plugin_used(&auth_manager, job).await;
@@ -240,29 +247,25 @@ impl AnalyticsEventsClient {
);
}
pub(crate) fn track_turn_metadata(
&self,
tracking: TrackEventsContext,
turn_metadata: TurnMetadata,
) {
track_turn_metadata(
pub(crate) fn track_turn_start(&self, tracking: TrackEventsContext, turn_start: TurnMetadata) {
track_turn_start(
&self.queue,
Arc::clone(&self.config),
Some(tracking),
turn_metadata,
turn_start,
);
}
pub(crate) fn track_input_message_metadata(
pub(crate) fn track_turn_steer(
&self,
tracking: TrackEventsContext,
input_message_metadata: UserMessageMetadata,
turn_steer: UserMessageMetadata,
) {
track_input_message_metadata(
track_turn_steer(
&self.queue,
Arc::clone(&self.config),
Some(tracking),
input_message_metadata,
turn_steer,
);
}
@@ -307,8 +310,8 @@ enum TrackEventsJob {
SkillInvocations(TrackSkillInvocationsJob),
AppMentioned(TrackAppMentionedJob),
AppUsed(TrackAppUsedJob),
TurnMetadata(TrackTurnMetadataJob),
InputMessageMetadata(TrackInputMessageMetadataJob),
TurnStart(TrackTurnStartJob),
TurnSteer(TrackTurnSteerJob),
PluginUsed(TrackPluginUsedJob),
PluginInstalled(TrackPluginManagementJob),
PluginUninstalled(TrackPluginManagementJob),
@@ -334,16 +337,16 @@ struct TrackAppUsedJob {
app: AppInvocation,
}
struct TrackTurnMetadataJob {
struct TrackTurnStartJob {
config: Arc<Config>,
tracking: TrackEventsContext,
turn_metadata: TurnMetadata,
turn_start: TurnMetadata,
}
struct TrackInputMessageMetadataJob {
struct TrackTurnSteerJob {
config: Arc<Config>,
tracking: TrackEventsContext,
input_message_metadata: UserMessageMetadata,
turn_steer: UserMessageMetadata,
}
struct TrackPluginUsedJob {
@@ -380,8 +383,7 @@ enum TrackEventRequest {
SkillInvocation(SkillInvocationEventRequest),
AppMentioned(CodexAppMentionedEventRequest),
AppUsed(CodexAppUsedEventRequest),
TurnMetadata(CodexTurnMetadataEventRequest),
InputMessageMetadata(CodexInputMessageMetadataEventRequest),
TurnEvent(CodexTurnEventRequest),
PluginUsed(CodexPluginUsedEventRequest),
PluginInstalled(CodexPluginEventRequest),
PluginUninstalled(CodexPluginEventRequest),
@@ -431,44 +433,31 @@ struct CodexAppUsedEventRequest {
}
#[derive(Serialize)]
struct CodexTurnMetadata {
thread_id: String,
turn_id: String,
product_client_id: Option<String>,
model: Option<String>,
turn_type: Option<TurnType>,
model_provider: String,
sandbox_policy: Option<&'static str>,
reasoning_effort: Option<String>,
reasoning_summary: Option<String>,
service_tier: String,
approval_policy: String,
approvals_reviewer: String,
sandbox_network_access: bool,
collaboration_mode: Option<&'static str>,
personality: Option<String>,
num_input_images: usize,
}
#[derive(Serialize)]
struct CodexTurnMetadataEventRequest {
event_type: &'static str,
event_params: CodexTurnMetadata,
}
#[derive(Serialize)]
struct CodexInputMessageMetadata {
struct CodexTurnEvent {
thread_id: Option<String>,
turn_id: Option<String>,
product_client_id: Option<String>,
model_slug: Option<String>,
turn_event_type: TurnEventType,
turn_type: Option<TurnType>,
user_message_type: Option<UserMessageType>,
model_provider: Option<String>,
sandbox_policy: Option<&'static str>,
reasoning_effort: Option<String>,
reasoning_summary: Option<String>,
service_tier: Option<String>,
approval_policy: Option<String>,
approvals_reviewer: Option<String>,
sandbox_network_access: Option<bool>,
collaboration_mode: Option<&'static str>,
personality: Option<String>,
num_input_images: Option<usize>,
}
#[derive(Serialize)]
struct CodexInputMessageMetadataEventRequest {
struct CodexTurnEventRequest {
event_type: &'static str,
event_params: CodexInputMessageMetadata,
event_params: CodexTurnEvent,
}
#[derive(Serialize)]
@@ -572,11 +561,11 @@ pub(crate) fn track_app_used(
queue.try_send(job);
}
pub(crate) fn track_turn_metadata(
pub(crate) fn track_turn_start(
queue: &AnalyticsEventsQueue,
config: Arc<Config>,
tracking: Option<TrackEventsContext>,
turn_metadata: TurnMetadata,
turn_start: TurnMetadata,
) {
if config.analytics_enabled == Some(false) {
return;
@@ -584,19 +573,19 @@ pub(crate) fn track_turn_metadata(
let Some(tracking) = tracking else {
return;
};
let job = TrackEventsJob::TurnMetadata(TrackTurnMetadataJob {
let job = TrackEventsJob::TurnStart(TrackTurnStartJob {
config,
tracking,
turn_metadata,
turn_start,
});
queue.try_send(job);
}
pub(crate) fn track_input_message_metadata(
pub(crate) fn track_turn_steer(
queue: &AnalyticsEventsQueue,
config: Arc<Config>,
tracking: Option<TrackEventsContext>,
input_message_metadata: UserMessageMetadata,
turn_steer: UserMessageMetadata,
) {
if config.analytics_enabled == Some(false) {
return;
@@ -604,10 +593,10 @@ pub(crate) fn track_input_message_metadata(
let Some(tracking) = tracking else {
return;
};
let job = TrackEventsJob::InputMessageMetadata(TrackInputMessageMetadataJob {
let job = TrackEventsJob::TurnSteer(TrackTurnSteerJob {
config,
tracking,
input_message_metadata,
turn_steer,
});
queue.try_send(job);
}
@@ -737,37 +726,30 @@ async fn send_track_app_used(auth_manager: &AuthManager, job: TrackAppUsedJob) {
send_track_events(auth_manager, config, events).await;
}
async fn send_track_turn_metadata(auth_manager: &AuthManager, job: TrackTurnMetadataJob) {
let TrackTurnMetadataJob {
async fn send_track_turn_start(auth_manager: &AuthManager, job: TrackTurnStartJob) {
let TrackTurnStartJob {
config,
tracking,
turn_metadata,
turn_start,
} = job;
let events = vec![TrackEventRequest::TurnMetadata(
CodexTurnMetadataEventRequest {
event_type: "codex_turn_metadata",
event_params: codex_turn_metadata(&tracking, turn_metadata),
},
)];
let events = vec![TrackEventRequest::TurnEvent(CodexTurnEventRequest {
event_type: "codex_turn_event",
event_params: codex_turn_start_event(&tracking, turn_start),
})];
send_track_events(auth_manager, config, events).await;
}
async fn send_track_input_message_metadata(
auth_manager: &AuthManager,
job: TrackInputMessageMetadataJob,
) {
let TrackInputMessageMetadataJob {
async fn send_track_turn_steer(auth_manager: &AuthManager, job: TrackTurnSteerJob) {
let TrackTurnSteerJob {
config,
tracking,
input_message_metadata,
turn_steer,
} = job;
let events = vec![TrackEventRequest::InputMessageMetadata(
CodexInputMessageMetadataEventRequest {
event_type: "codex_input_message_metadata",
event_params: codex_input_message_metadata(&tracking, input_message_metadata),
},
)];
let events = vec![TrackEventRequest::TurnEvent(CodexTurnEventRequest {
event_type: "codex_turn_event",
event_params: codex_turn_steer_event(&tracking, turn_steer),
})];
send_track_events(auth_manager, config, events).await;
}
@@ -836,45 +818,60 @@ fn codex_app_metadata(tracking: &TrackEventsContext, app: AppInvocation) -> Code
}
}
fn codex_turn_metadata(
fn codex_turn_start_event(
tracking: &TrackEventsContext,
turn_metadata: TurnMetadata,
) -> CodexTurnMetadata {
CodexTurnMetadata {
thread_id: tracking.thread_id.clone(),
turn_id: tracking.turn_id.clone(),
product_client_id: Some(crate::default_client::originator().value),
model: Some(tracking.model_slug.clone()),
turn_type: turn_metadata.turn_type,
model_provider: turn_metadata.model_provider,
sandbox_policy: Some(sandbox_policy_mode(&turn_metadata.sandbox_policy)),
reasoning_effort: turn_metadata
.reasoning_effort
.map(|value| value.to_string()),
reasoning_summary: reasoning_summary_mode(turn_metadata.reasoning_summary),
service_tier: turn_metadata
.service_tier
.map(|value| value.to_string())
.unwrap_or_else(|| "default".to_string()),
approval_policy: turn_metadata.approval_policy.to_string(),
approvals_reviewer: turn_metadata.approvals_reviewer.to_string(),
sandbox_network_access: turn_metadata.sandbox_network_access,
collaboration_mode: Some(collaboration_mode_mode(turn_metadata.collaboration_mode)),
personality: personality_mode(turn_metadata.personality),
num_input_images: turn_metadata.num_input_images,
}
}
fn codex_input_message_metadata(
tracking: &TrackEventsContext,
input_message_metadata: UserMessageMetadata,
) -> CodexInputMessageMetadata {
CodexInputMessageMetadata {
turn_start: TurnMetadata,
) -> CodexTurnEvent {
CodexTurnEvent {
thread_id: Some(tracking.thread_id.clone()),
turn_id: Some(tracking.turn_id.clone()),
product_client_id: Some(crate::default_client::originator().value),
model_slug: Some(tracking.model_slug.clone()),
user_message_type: Some(input_message_metadata.user_message_type),
turn_event_type: TurnEventType::Start,
turn_type: turn_start.turn_type,
user_message_type: None,
model_provider: Some(turn_start.model_provider),
sandbox_policy: Some(sandbox_policy_mode(&turn_start.sandbox_policy)),
reasoning_effort: turn_start.reasoning_effort.map(|value| value.to_string()),
reasoning_summary: reasoning_summary_mode(turn_start.reasoning_summary),
service_tier: Some(
turn_start
.service_tier
.map(|value| value.to_string())
.unwrap_or_else(|| "default".to_string()),
),
approval_policy: Some(turn_start.approval_policy.to_string()),
approvals_reviewer: Some(turn_start.approvals_reviewer.to_string()),
sandbox_network_access: Some(turn_start.sandbox_network_access),
collaboration_mode: Some(collaboration_mode_mode(turn_start.collaboration_mode)),
personality: personality_mode(turn_start.personality),
num_input_images: Some(turn_start.num_input_images),
}
}
fn codex_turn_steer_event(
tracking: &TrackEventsContext,
turn_steer: UserMessageMetadata,
) -> CodexTurnEvent {
CodexTurnEvent {
thread_id: Some(tracking.thread_id.clone()),
turn_id: Some(tracking.turn_id.clone()),
product_client_id: Some(crate::default_client::originator().value),
model_slug: Some(tracking.model_slug.clone()),
turn_event_type: TurnEventType::Steer,
turn_type: None,
user_message_type: Some(turn_steer.user_message_type),
model_provider: None,
sandbox_policy: None,
reasoning_effort: None,
reasoning_summary: None,
service_tier: None,
approval_policy: None,
approvals_reviewer: None,
sandbox_network_access: None,
collaboration_mode: None,
personality: None,
num_input_images: None,
}
}
codex-rs/core/src/analytics_client_tests.rs
+30 -16
View File
@@ -2,22 +2,22 @@ use super::AnalyticsEventsQueue;
use super::AppInvocation;
use super::CodexAppMentionedEventRequest;
use super::CodexAppUsedEventRequest;
use super::CodexInputMessageMetadataEventRequest;
use super::CodexPluginEventRequest;
use super::CodexPluginUsedEventRequest;
use super::CodexTurnMetadataEventRequest;
use super::CodexTurnEventRequest;
use super::InvocationType;
use super::TrackEventRequest;
use super::TrackEventsContext;
use super::TurnEventType;
use super::TurnMetadata;
use super::TurnType;
use super::UserMessageMetadata;
use super::UserMessageType;
use super::codex_app_metadata;
use super::codex_input_message_metadata;
use super::codex_plugin_metadata;
use super::codex_plugin_used_metadata;
use super::codex_turn_metadata;
use super::codex_turn_start_event;
use super::codex_turn_steer_event;
use super::normalize_path_for_skill_id;
use crate::plugins::AppConnectorId;
use crate::plugins::PluginCapabilitySummary;
@@ -202,15 +202,15 @@ fn app_used_dedupe_is_keyed_by_turn_and_connector() {
}
#[test]
fn turn_metadata_event_serializes_expected_shape() {
fn turn_start_event_serializes_expected_shape() {
let tracking = TrackEventsContext {
model_slug: "gpt-5".to_string(),
thread_id: "thread-2".to_string(),
turn_id: "turn-2".to_string(),
};
let event = TrackEventRequest::TurnMetadata(CodexTurnMetadataEventRequest {
event_type: "codex_turn_metadata",
event_params: codex_turn_metadata(
let event = TrackEventRequest::TurnEvent(CodexTurnEventRequest {
event_type: "codex_turn_event",
event_params: codex_turn_start_event(
&tracking,
TurnMetadata {
model_provider: "openai".to_string(),
@@ -234,13 +234,15 @@ fn turn_metadata_event_serializes_expected_shape() {
assert_eq!(
payload,
json!({
"event_type": "codex_turn_metadata",
"event_type": "codex_turn_event",
"event_params": {
"thread_id": "thread-2",
"turn_id": "turn-2",
"product_client_id": crate::default_client::originator().value,
"model": "gpt-5",
"model_slug": "gpt-5",
"turn_event_type": "start",
"turn_type": "prompt",
"user_message_type": null,
"model_provider": "openai",
"sandbox_policy": "read_only",
"reasoning_effort": "high",
@@ -258,15 +260,15 @@ fn turn_metadata_event_serializes_expected_shape() {
}
#[test]
fn input_message_metadata_event_serializes_expected_shape() {
fn turn_steer_event_serializes_expected_shape() {
let tracking = TrackEventsContext {
model_slug: "gpt-5".to_string(),
thread_id: "thread-2".to_string(),
turn_id: "turn-2".to_string(),
};
let event = TrackEventRequest::InputMessageMetadata(CodexInputMessageMetadataEventRequest {
event_type: "codex_input_message_metadata",
event_params: codex_input_message_metadata(
let event = TrackEventRequest::TurnEvent(CodexTurnEventRequest {
event_type: "codex_turn_event",
event_params: codex_turn_steer_event(
&tracking,
UserMessageMetadata {
user_message_type: UserMessageType::PromptSteering,
@@ -279,13 +281,25 @@ fn input_message_metadata_event_serializes_expected_shape() {
assert_eq!(
payload,
json!({
"event_type": "codex_input_message_metadata",
"event_type": "codex_turn_event",
"event_params": {
"thread_id": "thread-2",
"turn_id": "turn-2",
"product_client_id": crate::default_client::originator().value,
"model_slug": "gpt-5",
"user_message_type": "prompt_steering"
"turn_event_type": "steer",
"turn_type": null,
"user_message_type": "prompt_steering",
"sandbox_policy": null,
"reasoning_effort": null,
"reasoning_summary": null,
"service_tier": null,
"approval_policy": null,
"approvals_reviewer": null,
"sandbox_network_access": null,
"collaboration_mode": null,
"personality": null,
"num_input_images": null
}
})
);
codex-rs/core/src/codex.rs
+7 -9
View File
@@ -3938,14 +3938,12 @@ impl Session {
drop(turn_state);
drop(active);
if let Some(tracking) = self.active_turn_tracking().await {
self.services
.analytics_events_client
.track_input_message_metadata(
tracking,
UserMessageMetadata {
user_message_type: SubmittedUserMessageType::PromptSteering,
},
);
self.services.analytics_events_client.track_turn_steer(
tracking,
UserMessageMetadata {
user_message_type: SubmittedUserMessageType::PromptSteering,
},
);
}
Ok(active_turn_id)
}
@@ -5715,7 +5713,7 @@ pub(crate) async fn run_turn(
let user_message_type = turn_context
.user_message_type
.unwrap_or(SubmittedUserMessageType::Prompt);
sess.services.analytics_events_client.track_turn_metadata(
sess.services.analytics_events_client.track_turn_start(
tracking.clone(),
TurnMetadata {
model_provider: turn_context.config.model_provider_id.clone(),
codex-rs/core/tests/suite/items.rs
+14 -11
View File
@@ -163,7 +163,7 @@ async fn user_message_item_is_emitted() -> anyhow::Result<()> {
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn user_turn_tracks_turn_metadata_analytics() -> anyhow::Result<()> {
async fn user_turn_tracks_turn_start_analytics() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
@@ -234,11 +234,12 @@ async fn user_turn_tracks_turn_metadata_analytics() -> anyhow::Result<()> {
let event = payload["events"]
.as_array()
.and_then(|events| {
events
.iter()
.find(|event| event["event_type"] == "codex_turn_event")
events.iter().find(|event| {
event["event_type"] == "codex_turn_event"
&& event["event_params"]["turn_event_type"] == "start"
})
})
.expect("codex_turn_event should be present");
.expect("codex_turn_event start event should be present");
let event_params = &event["event_params"];
@@ -272,7 +273,7 @@ async fn user_turn_tracks_turn_metadata_analytics() -> anyhow::Result<()> {
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn user_turn_tracks_turn_type_prompt_metadata_analytics() -> anyhow::Result<()> {
async fn user_turn_tracks_turn_start_prompt_type_analytics() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
@@ -324,8 +325,9 @@ async fn user_turn_tracks_turn_type_prompt_metadata_analytics() -> anyhow::Resul
wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
let event = wait_for_analytics_event(&server, "codex_turn_metadata", |event| {
event["event_params"]["turn_type"] == "prompt"
let event = wait_for_analytics_event(&server, "codex_turn_event", |event| {
event["event_params"]["turn_event_type"] == "start"
&& event["event_params"]["turn_type"] == "prompt"
})
.await;
let event_params = &event["event_params"];
@@ -343,7 +345,7 @@ async fn user_turn_tracks_turn_type_prompt_metadata_analytics() -> anyhow::Resul
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn user_turn_tracks_input_message_prompt_steering_metadata_analytics() -> anyhow::Result<()> {
async fn user_turn_tracks_turn_steer_analytics() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
@@ -438,8 +440,9 @@ async fn user_turn_tracks_input_message_prompt_steering_metadata_analytics() ->
wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
let event = wait_for_analytics_event(&server, "codex_input_message_metadata", |event| {
event["event_params"]["user_message_type"] == "prompt_steering"
let event = wait_for_analytics_event(&server, "codex_turn_event", |event| {
event["event_params"]["turn_event_type"] == "steer"
&& event["event_params"]["user_message_type"] == "prompt_steering"
})
.await;
let event_params = &event["event_params"];