use crate::layer0::vocabulary::{HANDLE_MCARD_OBSERVABILITY_LOG, HANDLE_MCARD_OBSERVABILITY_METRIC, HANDLE_MCARD_OBSERVABILITY_TRACE};
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use rand::RngCore;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ObservabilityConfigRecord {
pub tempo_endpoint: String,
pub loki_endpoint: String,
pub mimir_endpoint: String,
pub sampling_rate: f64,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct TraceSpanRecord {
pub trace_id: String,
pub span_id: String,
pub parent_span_id: Option<String>,
pub pcard_handle: String,
pub vcard_hash: String,
pub duration_ms: u64,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct MetricRecord {
pub metric_name: String,
pub value: f64,
pub labels: serde_json::Value,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct StructuredLogRecord {
pub log_id: String,
pub trace_id: String,
pub level: String,
pub vcard_hash: String,
pub eoa_did: String,
pub message: String,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
fn resolve_db_path(db_name_or_path: &str, clm_root: Option<&str>) -> PathBuf {
if db_name_or_path.contains('/') || db_name_or_path.contains('\\') {
PathBuf::from(db_name_or_path)
} else {
let root = clm_root.map(PathBuf::from).unwrap_or_else(|| {
std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
});
root.join("data").join("execution_logs").join(db_name_or_path)
}
}
fn init_db_tables(conn: &Connection) -> Result<(), String> {
let _ = conn.busy_timeout(std::time::Duration::from_millis(u64::from(crate::layer0::runtime_contract::SQLITE_BUSY_TIMEOUT_MS)));
conn.execute_batch(crate::layer0::runtime_contract::SQLITE_DDL_V3_1).map_err(|e| e.to_string())?;
let has_hash: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'hash'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if has_hash {
let has_curr: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'current_hash'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if !has_curr {
let _ = conn.execute_batch("ALTER TABLE handle_registry RENAME COLUMN hash TO current_hash;");
}
}
let has_updated_at: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'updated_at'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if !has_updated_at {
let _ = conn.execute_batch("ALTER TABLE handle_registry ADD COLUMN updated_at TEXT NOT NULL DEFAULT '';");
}
Ok(())
}
fn generate_sha256(content: &str) -> String {
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update(content.as_bytes());
hex::encode(hasher.finalize())
}
pub fn configure_observability(
db_name_or_path: &str,
clm_root: Option<&str>,
tempo_endpoint: &str,
loki_endpoint: &str,
mimir_endpoint: &str,
sampling_rate: Option<f64>,
) -> Result<ObservabilityConfigRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let rate = sampling_rate.unwrap_or(1.0);
let handle = crate::layer0::vocabulary::HANDLE_MCARD_OBSERVABILITY_CONFIG.to_string();
let json_val = serde_json::json!({
"type": "observability_config",
"tempo_endpoint": tempo_endpoint,
"loki_endpoint": loki_endpoint,
"mimir_endpoint": mimir_endpoint,
"sampling_rate": rate
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?1, ?2, ?3) ON CONFLICT(hash) DO UPDATE SET content=excluded.content;",
rusqlite::params![content_hash, content_json, crate::fs_utils::compute_g_time()],
).map_err(|e| e.to_string())?;
let now = chrono::Utc::now().to_rfc3339();
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, now],
).map_err(|e| e.to_string())?;
Ok(ObservabilityConfigRecord {
tempo_endpoint: tempo_endpoint.to_string(),
loki_endpoint: loki_endpoint.to_string(),
mimir_endpoint: mimir_endpoint.to_string(),
sampling_rate: rate,
handle,
content_hash,
})
}
pub fn emit_trace_span(
db_name_or_path: &str,
clm_root: Option<&str>,
trace_id: &str,
span_id: &str,
parent_span_id: Option<&str>,
pcard_handle: &str,
vcard_hash: &str,
duration_ms: u64,
) -> Result<TraceSpanRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let timestamp = chrono::Utc::now().to_rfc3339();
let handle = format!("{HANDLE_MCARD_OBSERVABILITY_TRACE}{}", trace_id);
let json_val = serde_json::json!({
"type": "trace_span",
"trace_id": trace_id,
"span_id": span_id,
"parent_span_id": parent_span_id,
"pcard_handle": pcard_handle,
"vcard_hash": vcard_hash,
"duration_ms": duration_ms,
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?1, ?2, ?3) ON CONFLICT(hash) DO UPDATE SET content=excluded.content;",
rusqlite::params![content_hash, content_json, crate::fs_utils::compute_g_time()],
).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(TraceSpanRecord {
trace_id: trace_id.to_string(),
span_id: span_id.to_string(),
parent_span_id: parent_span_id.map(|s| s.to_string()),
pcard_handle: pcard_handle.to_string(),
vcard_hash: vcard_hash.to_string(),
duration_ms,
timestamp,
handle,
content_hash,
})
}
pub fn record_metric(
db_name_or_path: &str,
clm_root: Option<&str>,
metric_name: &str,
value: f64,
labels_json: Option<&str>,
) -> Result<MetricRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let timestamp = chrono::Utc::now().to_rfc3339();
let handle = format!("{HANDLE_MCARD_OBSERVABILITY_METRIC}{}", metric_name);
let labels: serde_json::Value = match labels_json {
Some(s) => serde_json::from_str(s).unwrap_or_else(|_| serde_json::json!({})),
None => serde_json::json!({}),
};
let json_val = serde_json::json!({
"type": "metric_event",
"metric_name": metric_name,
"value": value,
"labels": labels,
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?1, ?2, ?3) ON CONFLICT(hash) DO UPDATE SET content=excluded.content;",
rusqlite::params![content_hash, content_json, crate::fs_utils::compute_g_time()],
).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(MetricRecord {
metric_name: metric_name.to_string(),
value,
labels,
timestamp,
handle,
content_hash,
})
}
pub fn emit_structured_log(
db_name_or_path: &str,
clm_root: Option<&str>,
trace_id: &str,
level: &str,
vcard_hash: &str,
eoa_did: &str,
message: &str,
) -> Result<StructuredLogRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let mut log_bytes = [0u8; 8];
rand::thread_rng().fill_bytes(&mut log_bytes);
let log_id = format!("log_{}", hex::encode(log_bytes));
let handle = format!("{HANDLE_MCARD_OBSERVABILITY_LOG}{}", log_id);
let timestamp = chrono::Utc::now().to_rfc3339();
let json_val = serde_json::json!({
"type": "structured_log",
"log_id": log_id,
"trace_id": trace_id,
"level": level,
"vcard_hash": vcard_hash,
"eoa_did": eoa_did,
"message": message,
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?1, ?2, ?3) ON CONFLICT(hash) DO UPDATE SET content=excluded.content;",
rusqlite::params![content_hash, content_json, crate::fs_utils::compute_g_time()],
).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(StructuredLogRecord {
log_id,
trace_id: trace_id.to_string(),
level: level.to_string(),
vcard_hash: vcard_hash.to_string(),
eoa_did: eoa_did.to_string(),
message: message.to_string(),
timestamp,
handle,
content_hash,
})
}
pub fn get_trace(
db_name_or_path: &str,
clm_root: Option<&str>,
trace_id: &str,
) -> Result<TraceSpanRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if !db_path.exists() {
return Err(format!("Database not found for trace {}", trace_id));
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
let handle = format!("{HANDLE_MCARD_OBSERVABILITY_TRACE}{}", trace_id);
let query = if conn.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'current_hash'",
[],
|r| r.get(0),
).unwrap_or(false) {
"SELECT c.content, c.hash FROM card c JOIN handle_registry h ON c.hash = h.current_hash WHERE h.handle = ?1;"
} else {
"SELECT c.content, c.hash FROM card c JOIN handle_registry h ON c.hash = h.hash WHERE h.handle = ?1;"
};
let (content, content_hash): (String, String) = conn.query_row(
query,
rusqlite::params![handle],
|row| {
let c: String = row.get(0)?;
let h: String = row.get(1)?;
Ok((c, h))
},
).map_err(|_| format!("Trace span {} not found", trace_id))?;
let v: serde_json::Value = serde_json::from_str(&content).map_err(|e| e.to_string())?;
Ok(TraceSpanRecord {
trace_id: v.get("trace_id").and_then(|x| x.as_str()).unwrap_or(trace_id).to_string(),
span_id: v.get("span_id").and_then(|x| x.as_str()).unwrap_or("").to_string(),
parent_span_id: v.get("parent_span_id").and_then(|x| x.as_str()).map(|x| x.to_string()),
pcard_handle: v.get("pcard_handle").and_then(|x| x.as_str()).unwrap_or("").to_string(),
vcard_hash: v.get("vcard_hash").and_then(|x| x.as_str()).unwrap_or("").to_string(),
duration_ms: v.get("duration_ms").and_then(|x| x.as_u64()).unwrap_or(0),
timestamp: v.get("timestamp").and_then(|x| x.as_str()).unwrap_or("").to_string(),
handle,
content_hash,
})
}
pub fn get_metric(
db_name_or_path: &str,
clm_root: Option<&str>,
metric_name: &str,
) -> Result<MetricRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if !db_path.exists() {
return Err(format!("Database not found for metric {}", metric_name));
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
let handle = format!("{HANDLE_MCARD_OBSERVABILITY_METRIC}{}", metric_name);
let query = if conn.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'current_hash'",
[],
|r| r.get(0),
).unwrap_or(false) {
"SELECT c.content, c.hash FROM card c JOIN handle_registry h ON c.hash = h.current_hash WHERE h.handle = ?1;"
} else {
"SELECT c.content, c.hash FROM card c JOIN handle_registry h ON c.hash = h.hash WHERE h.handle = ?1;"
};
let (content, content_hash): (String, String) = conn.query_row(
query,
rusqlite::params![handle],
|row| {
let c: String = row.get(0)?;
let h: String = row.get(1)?;
Ok((c, h))
},
).map_err(|_| format!("Metric {} not found", metric_name))?;
let v: serde_json::Value = serde_json::from_str(&content).map_err(|e| e.to_string())?;
Ok(MetricRecord {
metric_name: v.get("metric_name").and_then(|x| x.as_str()).unwrap_or(metric_name).to_string(),
value: v.get("value").and_then(|x| x.as_f64()).unwrap_or(0.0),
labels: v.get("labels").cloned().unwrap_or_else(|| serde_json::json!({})),
timestamp: v.get("timestamp").and_then(|x| x.as_str()).unwrap_or("").to_string(),
handle,
content_hash,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_observability_pipeline() {
let db_path = "/tmp/test_observability.db";
let _ = std::fs::remove_file(db_path);
let cfg = configure_observability(db_path, None, "http://localhost:4317", "http://localhost:3100", "http://localhost:9009", Some(1.0)).unwrap();
assert_eq!(cfg.tempo_endpoint, "http://localhost:4317");
let trace = emit_trace_span(db_path, None, "tr_001", "sp_001", None, "pcard:auth/verify", "0xhash123", 42).unwrap();
assert_eq!(trace.trace_id, "tr_001");
let fetched_trace = get_trace(db_path, None, "tr_001").unwrap();
assert_eq!(fetched_trace.duration_ms, 42);
assert_eq!(fetched_trace.vcard_hash, "0xhash123");
let metric = record_metric(db_path, None, "pkc_auth_success_total", 1.0, Some(r#"{"provider":"zitadel"}"#)).unwrap();
assert_eq!(metric.metric_name, "pkc_auth_success_total");
let fetched_metric = get_metric(db_path, None, "pkc_auth_success_total").unwrap();
assert_eq!(fetched_metric.value, 1.0);
let log_rec = emit_structured_log(db_path, None, "tr_001", "INFO", "0xhash123", "did:key:z6MkAgent", "Auth challenge verified").unwrap();
assert_eq!(log_rec.level, "INFO");
let _ = std::fs::remove_file(db_path);
}
}