systemprompt-analytics 0.53.0

Analytics for systemprompt.io AI governance infrastructure. Session, agent, tool, and microdollar-precision cost attribution across the MCP governance pipeline.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Indexed dimensions derived from validated typed facts, never independently
//! asserted.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

use super::validation;
use crate::Result;
use systemprompt_identifiers::{
    AnalyticsFactId, DeviceId, ManagedResourceId, NativeSessionId, ResourceRevisionId, UserId,
};
use systemprompt_models::feedback::analytics::{
    AssessmentOutcome, InvocationConsumerIdentity, InvocationResourceAttribution,
    NormalizedAnalyticsFact, RecordedSpend,
};

#[derive(Default)]
pub(super) struct Columns {
    pub consumer: Option<UserId>,
    pub device: Option<DeviceId>,
    pub host: Option<String>,
    pub session: Option<NativeSessionId>,
    pub resource: Option<ManagedResourceId>,
    pub resource_revision: Option<ResourceRevisionId>,
    pub invocation_source: Option<String>,
    pub invocation: Option<AnalyticsFactId>,
    pub request_source: Option<String>,
    pub request: Option<AnalyticsFactId>,
    pub succeeded: Option<bool>,
    pub currency: Option<String>,
    pub amount: Option<i64>,
    pub input: Option<i64>,
    pub output: Option<i64>,
    pub latency: Option<i64>,
    pub conversation_source: Option<String>,
    pub conversation: Option<AnalyticsFactId>,
    pub assessment: Option<String>,
    pub score: Option<i64>,
}

impl Columns {
    pub(super) fn of(source: &str, fact: Option<&NormalizedAnalyticsFact>) -> Result<Self> {
        let mut columns = Self::default();
        match fact {
            Some(NormalizedAnalyticsFact::Invocation(value)) => {
                columns.identity(&value.consumer)?;
                columns.attribution(&value.attribution);
                columns.invocation_source = Some(source.to_owned());
                columns.invocation = Some(AnalyticsFactId::new(value.invocation_id.as_str()));
                columns.succeeded = Some(value.succeeded);
                columns.latency = validation::bounded(value.latency_micros)?;
            },
            Some(NormalizedAnalyticsFact::Request(value)) => {
                columns.identity(&value.consumer)?;
                columns.succeeded = Some(value.succeeded);
                columns.input = validation::bounded(value.input_tokens)?;
                columns.output = validation::bounded(value.output_tokens)?;
                columns.latency = validation::bounded(value.latency_micros)?;
                if let RecordedSpend::Known {
                    currency,
                    amount_micros,
                } = &value.spend
                {
                    columns.currency = Some(currency.clone());
                    columns.amount = validation::bounded(Some(*amount_micros))?;
                }
            },
            Some(NormalizedAnalyticsFact::Assessment(value)) => {
                columns.conversation_source = Some(value.conversation_key.source.clone());
                columns.conversation = Some(value.conversation_key.id.clone());
                columns.invocation_source = Some(value.invocation_key.source.clone());
                columns.invocation = Some(value.invocation_key.id.clone());
                columns.assessment = Some(
                    match value.outcome {
                        AssessmentOutcome::Scored { score_millionths } => {
                            columns.score = Some(score_millionths);
                            "scored"
                        },
                        AssessmentOutcome::Failed => "failed",
                        AssessmentOutcome::Unavailable => "unavailable",
                    }
                    .to_owned(),
                );
            },
            Some(NormalizedAnalyticsFact::ResourceAssociation(value)) => {
                columns.attribution(&value.attribution);
                columns.invocation_source = Some(value.invocation_key.source.clone());
                columns.invocation = Some(value.invocation_key.id.clone());
                columns.request_source = Some(value.request_key.source.clone());
                columns.request = Some(value.request_key.id.clone());
            },
            None => {},
        }
        Ok(columns)
    }

    fn identity(&mut self, identity: &InvocationConsumerIdentity) -> Result<()> {
        if let InvocationConsumerIdentity::Authenticated {
            consumer_id,
            device_id,
            host,
            session_id,
        } = identity
        {
            self.consumer = Some(consumer_id.clone());
            self.device = Some(device_id.clone());
            self.host = serde_json::to_value(host)?.as_str().map(str::to_owned);
            self.session = Some(session_id.clone());
        }
        Ok(())
    }

    fn attribution(&mut self, attribution: &InvocationResourceAttribution) {
        if let InvocationResourceAttribution::Verified {
            resource_id,
            revision_id,
        } = attribution
        {
            self.resource = Some(resource_id.clone());
            self.resource_revision = Some(revision_id.clone());
        }
    }
}