Skip to content
Python
8.6 KB
Raw Blame
//! Deterministic metadata/usage fixture; no actual model or tool is invoked.
//! Pass CONFIG.json NEW_OUTPUT_DIRECTORY. Export credentials are env references.
use anyhow::{ensure, Result};
use openworker_observability::{
    query::{Page, Query, Scope},
    sqlite::Sqlite,
    summary::{self, Canonical},
    Recorder, RecordingSink, Store,
};
use openworker_telemetry::{
    attributes as a, otlp, scope_turn, Capture, ContentPolicy, ModelPurpose, Operation, Outcome,
    Telemetry, TokenUsage, TraceContext,
};
use serde_json::json;
use std::{
    path::PathBuf,
    time::{Duration, SystemTime, UNIX_EPOCH},
};
fn now() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis() as u64
}
fn runtime() -> tokio::runtime::Runtime {
    tokio::runtime::Builder::new_current_thread()
        .enable_time()
        .build()
        .unwrap()
}
fn model(
    t: &Telemetry,
    purpose: ModelPurpose,
    attempt: u32,
    usage: Option<TokenUsage>,
    outcome: Outcome,
) {
    let mut s = t.span(
        Operation::Model,
        Some("PRIVATE_SESSION"),
        Some("PRIVATE_CALL"),
    );
    s.purpose(purpose);
    s.attempt(attempt);
    s.metadata(a::MODEL_NAME, "fixture-model");
    s.model_started();
    s.content_tail(a::PROMPT, || {
        "PRIVATE_PROMPT sk-notarealsecret1234567890".into()
    });
    s.content(a::COMPLETION, || "PRIVATE_ANSWER".into());
    if let Some(usage) = usage {
        s.reported_usage(usage);
    }
    s.first_output();
    s.finish(outcome);
}
fn main() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let config: otlp::Config = serde_json::from_slice(&std::fs::read(
        args.next()
            .ok_or_else(|| anyhow::anyhow!("Config path required"))?,
    )?)?;
    let output = PathBuf::from(
        args.next()
            .ok_or_else(|| anyhow::anyhow!("New output directory required"))?,
    );
    ensure!(args.next().is_none(), "Unexpected arguments");
    std::fs::create_dir(&output)?;
    let database = output.join("recording.sqlite");
    let (recorder, done) = Recorder::start(
        Box::new(Sqlite::open(&database)?),
        config.deployment.clone(),
        64,
        30,
    )?;
    let mut previous: Option<TraceContext> = None;
    let mut first_started = 0;
    let mut pauses = vec![];
    let mut snapshots = vec![];
    for worker in 0..2 {
        let sink = RecordingSink::new(
            recorder.clone(),
            config.deployment.clone(),
            format!("worker-{worker}"),
            Some(Box::new(config.build_sink("worker")?)),
            config.content.capture,
        )?;
        // Recording may capture approved names without enabling remote metadata export.
        let (t, c) = Telemetry::start_with_content(
            sink,
            64,
            ContentPolicy {
                capture: Capture::Metadata.max(config.content.capture),
                ..config.content.clone()
            },
        )?;
        let mut root = t.span(
            Operation::Turn,
            Some("PRIVATE_SESSION"),
            Some("PRIVATE_TURN"),
        );
        root.turn("PRIVATE_TURN");
        if let Some(p) = previous {
            root.link(p);
        }
        let cx = root.context();
        if worker == 0 {
            first_started = now();
        }
        runtime().block_on(scope_turn("PRIVATE_TURN", cx, async {
            if worker == 0 {
                model(
                    &t,
                    ModelPurpose::Main,
                    1,
                    Some(TokenUsage {
                        input: Some(10),
                        output: Some(2),
                        ..Default::default()
                    }),
                    Outcome::Error,
                );
                model(
                    &t,
                    ModelPurpose::Main,
                    2,
                    Some(TokenUsage {
                        input: Some(100),
                        output: Some(20),
                        cache_read: Some(40),
                        cache_write: Some(10),
                        reasoning: Some(5),
                    }),
                    Outcome::Ok,
                );
                let policy = t.span(Operation::Policy, Some("PRIVATE_SESSION"), None);
                let pc = policy.context();
                openworker_telemetry::scope(pc, async {
                    model(
                        &t,
                        ModelPurpose::AutoApprover,
                        1,
                        Some(TokenUsage {
                            input: Some(0),
                            output: Some(0),
                            ..Default::default()
                        }),
                        Outcome::Ok,
                    )
                })
                .await;
                policy.finish(Outcome::Ok);
            } else {
                model(&t, ModelPurpose::Compaction, 1, None, Outcome::Ok);
                let mut tool = t.span(
                    Operation::Tool,
                    Some("PRIVATE_SESSION"),
                    Some("PRIVATE_TOOL_CALL"),
                );
                tool.metadata(a::TOOL_NAME, "fixture.read_file");
                tool.metadata(a::SANDBOX_PROVIDER, "off");
                tool.metadata(a::SANDBOX_ENFORCEMENT, "none");
                tool.output_bytes(512);
                tool.content(a::TOOL_ARGUMENTS, || "PRIVATE_ARGUMENTS".into());
                tool.content(a::TOOL_RESULT, || "PRIVATE_RESULT".into());
                tool.finish(Outcome::Unknown);
            }
        }));
        root.finish(if worker == 0 {
            Outcome::Waiting
        } else {
            Outcome::Ok
        });
        if worker == 0 {
            let start = now();
            std::thread::sleep(Duration::from_millis(10));
            let end = now();
            t.interval(
                Operation::ApprovalWait,
                Outcome::Ok,
                "PRIVATE_SESSION",
                "PRIVATE_TURN",
                "PRIVATE_APPROVAL",
                start,
                end,
            );
            pauses.push(end - start);
        }
        ensure!(
            c.shutdown(Duration::from_secs(5)),
            "Export dispatcher did not drain"
        );
        snapshots.push(c.snapshot());
        previous = Some(cx);
    }
    ensure!(
        done.shutdown(Duration::from_secs(5)),
        "Recorder did not drain"
    );
    let mut sql = Sqlite::open(&database)?;
    let session = openworker_runtime_digest("PRIVATE_SESSION");
    let turn = openworker_runtime_digest("PRIVATE_TURN");
    let page: Page = sql.timeline(&Query {
        deployment: config.deployment.clone(),
        scopes: vec![Scope {
            session_hash: session,
            turn_hash: turn,
        }],
        after: 0,
        through: None,
        limit: 4096,
    })?;
    let last = previous
        .unwrap()
        .span
        .iter()
        .map(|b| format!("{b:02x}"))
        .collect();
    let summary = summary::build(
        &page,
        Canonical {
            terminal: true,
            expected_segments: Some(2),
            first_started_ms: Some(first_started),
            last_span_id: Some(last),
            pending_waits: Some(0),
        },
    );
    ensure!(
        summary.usage.input.total == Some(110) && summary.usage.output.total == Some(22),
        "Fixture usage drift"
    );
    ensure!(
        summary.usage.input.known == 3 && summary.usage.input.unknown == 1,
        "Fixture missing-usage drift"
    );
    let encoded = serde_json::to_string(&page)?;
    ensure!(
        !encoded.contains("PRIVATE") && !encoded.contains("sk-notareal"),
        "Recording content leak"
    );
    std::fs::write(
        output.join("records.json"),
        serde_json::to_vec_pretty(&page)?,
    )?;
    std::fs::write(
        output.join("summary.json"),
        serde_json::to_vec_pretty(&summary)?,
    )?;
    std::fs::write(
        output.join("probe.json"),
        serde_json::to_vec_pretty(
            &json!({"version":1,"fixture":"export_reconciliation","capture":config.content.capture,"exporter":snapshots,"recording":recorder.statistics().snapshot(),"pause_ms":pauses,"steps":page.steps.len(),"schema":a::VERSION,"semconv":a::SEMCONV}),
        )?,
    )?;
    println!("export probe: {} recorded steps", page.steps.len());
    Ok(())
}
fn openworker_runtime_digest(value: &str) -> String {
    // Use the shared typed identity hashing contract, not a second implementation.
    openworker_telemetry::Identity::new(Some(value), None)
        .session
        .unwrap()
        .iter()
        .map(|b| format!("{b:02x}"))
        .collect()
}