Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

telemetry

eugene7a983e8fd4db
diff --git a/Cargo.lock b/Cargo.lock
index b1471ab7a..d609b76f1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3890,6 +3890,7 @@ version = "0.5.4"
dependencies = [
"bindings",
"bindings-types",
+ "chrono",
"futures",
"hanashi",
"indexmap 2.14.0",
@@ -3910,6 +3911,7 @@ dependencies = [
"tokio",
"tokio-stream",
"tokio-util",
+ "tracing",
"tsify",
"uniffi",
"wasm-bindgen",
diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h
index 3d31a15bd..82202985f 100644
--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h
+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h
@@ -282,8 +282,9 @@ struct MxuMmaCore {
(simdgroup_limit_n == SIMDGROUP_BLOCK_N),
[&](auto aligned_n) {
auto accumulator_tile = [&]() {
- if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::FullPrecision) {
+ if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::FullPrecision
+ ) {
const int aligned_k_iterations_fp =
int(params->aligned_inner_iterations);
return uzu::matmul::gemm_loop<
@@ -328,8 +329,9 @@ struct MxuMmaCore {
scales + block_col * groups_per_row + k_offset_groups;
auto loader_b = [&]() {
- if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::ScaleBiasDequant) {
+ if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant
+ ) {
const device BT* biases_offset =
biases + block_col * groups_per_row +
k_offset_groups;
@@ -342,9 +344,10 @@ struct MxuMmaCore {
thread_context.simdgroup_index,
thread_context.simd_lane_id
);
- } else if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::
- ScaleZeroPointDequant) {
+ } else if constexpr (
+ B_PROLOGUE ==
+ GemmBPrologueKind::ScaleZeroPointDequant
+ ) {
const int zero_point_stride_per_row =
(BITS == 4) ? ((groups_per_row + 1) / 2)
: groups_per_row;
diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h
index ce4cd08b1..1ce69ed3b 100644
--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h
+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h
@@ -175,8 +175,10 @@ struct SimdgroupMmaCore {
const thread ThreadContext& thread_context
) {
constexpr GemmAlignment gemm_alignment{GEMM_ALIGNMENT_RAW};
- if constexpr (gemm_alignment.contains(GemmAlignment::M) &&
- gemm_alignment.contains(GemmAlignment::N)) {
+ if constexpr (
+ gemm_alignment.contains(GemmAlignment::M) &&
+ gemm_alignment.contains(GemmAlignment::N)
+ ) {
if (needs_epilogue) {
accumulator.apply_epilogue(d, params->leading_dimension_d, 1, epilogue);
}
@@ -327,8 +329,9 @@ struct SimdgroupMmaCore {
thread_context.simdgroup_index,
thread_context.simd_lane_id
);
- } else if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::ScaleZeroPointDequant) {
+ } else if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant
+ ) {
const int zero_point_stride_per_row =
(BITS == 4) ? ((groups_per_row + 1) / 2) : groups_per_row;
const device uint8_t* zero_points_row_start =
diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h
index a60b59081..a9fa82495 100644
--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h
+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h
@@ -111,8 +111,9 @@ struct BSource {
prep.scales = scales + out_row * in_vec_size_g + g_offset;
if constexpr (B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant) {
prep.biases = biases + out_row * in_vec_size_g + g_offset;
- } else if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::ScaleZeroPointDequant) {
+ } else if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant
+ ) {
if (BITS == 4) {
prep.zp_stride = (in_vec_size_g + 1) / 2;
prep.zps = zero_points + out_row * prep.zp_stride + g_offset / 2;
diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h
index d3cdbd85d..0965132c0 100644
--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h
+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h
@@ -30,8 +30,9 @@ struct QuantRowOffsets {
offset[1] = static_cast<U>(biases[group_stride]);
offset[2] = static_cast<U>(biases[2 * group_stride]);
offset[3] = static_cast<U>(biases[3 * group_stride]);
- } else if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::ScaleZeroPointDequant) {
+ } else if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant
+ ) {
uchar4 zp_bytes = uchar4(
zps[0],
zps[zp_stride],
@@ -62,8 +63,9 @@ struct QuantRowOffsets {
scales += groups;
if constexpr (B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant) {
biases += groups;
- } else if constexpr (B_PROLOGUE ==
- GemmBPrologueKind::ScaleZeroPointDequant) {
+ } else if constexpr (
+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant
+ ) {
constexpr uint zps_per_byte = get_pack_factor<BITS, 8>();
zps += groups / zps_per_byte;
}
diff --git a/crates/nagare/Cargo.toml b/crates/nagare/Cargo.toml
index 83e6634e9..3d4b871d5 100644
--- a/crates/nagare/Cargo.toml
+++ b/crates/nagare/Cargo.toml
@@ -56,6 +56,8 @@ shoji.workspace = true
hanashi.workspace = true
serde.workspace = true
serde_json.workspace = true
+chrono.workspace = true
+tracing.workspace = true
thiserror.workspace = true
indexmap.workspace = true
reqwest.workspace = true
diff --git a/crates/nagare/src/api/client.rs b/crates/nagare/src/api/client.rs
index 04286dbe5..ceab74273 100644
--- a/crates/nagare/src/api/client.rs
+++ b/crates/nagare/src/api/client.rs
@@ -28,6 +28,40 @@ impl Client {
&self,
endpoint: &E,
) -> Result<T, Error> {
+ let response = self.send_checked(endpoint).await?;
+ response.json::<T>().await.map_err(|error| Error::Decode(error.to_string()))
+ }
+
+ pub async fn send<E: Endpoint>(
+ &self,
+ endpoint: &E,
+ ) -> Result<(), Error> {
+ self.send_checked(endpoint).await?;
+ Ok(())
+ }
+}
+
+impl Client {
+ async fn send_checked<E: Endpoint>(
+ &self,
+ endpoint: &E,
+ ) -> Result<reqwest::Response, Error> {
+ let response = self.build_request(endpoint).send().await?;
+ let status = response.status();
+ if !status.is_success() {
+ let body = response.text().await.unwrap_or_default();
+ return Err(Error::Http {
+ code: status.as_u16(),
+ body,
+ });
+ }
+ Ok(response)
+ }
+
+ fn build_request<E: Endpoint>(
+ &self,
+ endpoint: &E,
+ ) -> reqwest::RequestBuilder {
let url = self.url(endpoint);
let method = endpoint.method();
let payload = endpoint.payload(&self.config);
@@ -47,21 +81,9 @@ impl Client {
for (key, value) in endpoint.headers().iter() {
request = request.header(key, value);
}
-
- let response = request.send().await?;
- let status = response.status();
- if !status.is_success() {
- let body = response.text().await.unwrap_or_default();
- return Err(Error::Http {
- code: status.as_u16(),
- body,
- });
- }
- response.json::<T>().await.map_err(|error| Error::Decode(error.to_string()))
+ request
}
-}
-impl Client {
fn url<E: Endpoint>(
&self,
endpoint: &E,
diff --git a/crates/nagare/src/chat/mod.rs b/crates/nagare/src/chat/mod.rs
index 9f2abeb28..aa62f297b 100644
--- a/crates/nagare/src/chat/mod.rs
+++ b/crates/nagare/src/chat/mod.rs
@@ -21,6 +21,8 @@ use shoji::{
};
use tokio::sync::{Mutex, mpsc};
+use crate::telemetry::{Telemetry, TelemetryEvent};
+
#[bindings::export(Enumeration)]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ChatSessionStreamChunk {
@@ -80,6 +82,8 @@ pub struct ChatSession {
instance: Arc<Mutex<Instance>>,
state: Arc<Mutex<ChatSessionState>>,
messages: Arc<Mutex<Vec<ChatMessage>>>,
+ model_id: String,
+ telemetry: Telemetry,
}
impl ChatSession {
@@ -88,10 +92,12 @@ impl ChatSession {
config: ChatConfig,
model: Model,
path: Option<String>,
+ telemetry: Telemetry,
) -> Result<Self, ChatSessionError> {
if !model.specializations.contains(&ModelSpecialization::Chat {}) {
return Err(ChatSessionError::UnsupportedModel {});
}
+ let model_id = model.identifier.clone();
let reference = path.unwrap_or_else(|| model.identifier.clone());
let instance = tokio::spawn(async move {
@@ -112,6 +118,8 @@ impl ChatSession {
instance: Arc::new(Mutex::new(instance)),
state: Arc::new(Mutex::new(ChatSessionState::Idle)),
messages: Arc::new(Mutex::new(Vec::new())),
+ model_id,
+ telemetry,
})
}
}
@@ -189,6 +197,8 @@ impl ChatSession {
let instance = self.instance.clone();
let state = self.state.clone();
let messages = self.messages.clone();
+ let telemetry = self.telemetry.clone();
+ let model_id = self.model_id.clone();
let cancel_token = cancel_token_to_return.inner().clone();
tokio::spawn(async move {
@@ -206,6 +216,10 @@ impl ChatSession {
drop(state);
}
+ telemetry.report(TelemetryEvent::ModelInferenceStarted {
+ model_id: model_id.clone(),
+ });
+
let all_messages = {
let mut messages = messages.lock().await;
messages.extend(input);
@@ -221,6 +235,7 @@ impl ChatSession {
};
let turn_index: u32 = 0;
+ let mut errored = false;
while let Some(partial_output) = stream.next().await {
match partial_output {
Ok(backend_output) => {
@@ -246,6 +261,10 @@ impl ChatSession {
}
},
Err(error) => {
+ errored = true;
+ telemetry.report(TelemetryEvent::ModelInferenceFailed {
+ error: serde_json::json!({ "message": error.to_string() }),
+ });
let _ = sender.send(Err(error));
break;
},
@@ -259,6 +278,13 @@ impl ChatSession {
let mut state = state.lock().await;
*state = ChatSessionState::Idle;
}
+
+ if !errored && let Some(last) = outputs.values().last() {
+ telemetry.report(TelemetryEvent::ModelInferenceFinished {
+ model_id,
+ stats: last.stats.clone(),
+ });
+ }
});
ChatSessionStream {
diff --git a/crates/nagare/src/lib.rs b/crates/nagare/src/lib.rs
index daefce84a..3aa2d5625 100644
--- a/crates/nagare/src/lib.rs
+++ b/crates/nagare/src/lib.rs
@@ -4,4 +4,5 @@ uniffi::setup_scaffolding!();
pub mod api;
pub mod chat;
pub mod classification;
+pub mod telemetry;
pub mod text_to_speech;
diff --git a/crates/nagare/src/telemetry/endpoint.rs b/crates/nagare/src/telemetry/endpoint.rs
new file mode 100644
index 000000000..b8210b971
--- /dev/null
+++ b/crates/nagare/src/telemetry/endpoint.rs
@@ -0,0 +1,99 @@
+use indexmap::IndexMap;
+use reqwest::{Method, header::CONTENT_TYPE};
+use serde_json::Value;
+
+use super::record::TelemetryRecord;
+use crate::api::{Config, Endpoint, Payload};
+
+pub(super) struct TelemetryEndpoint {
+ path: String,
+ body: Value,
+}
+
+impl TelemetryEndpoint {
+ pub(super) fn new(
+ path: String,
+ context: &Value,
+ record: &TelemetryRecord,
+ ) -> Self {
+ Self {
+ path,
+ body: build_body(context, record),
+ }
+ }
+}
+
+impl Endpoint for TelemetryEndpoint {
+ fn method(&self) -> Method {
+ Method::POST
+ }
+
+ fn path(&self) -> String {
+ self.path.clone()
+ }
+
+ fn headers(&self) -> IndexMap<String, String> {
+ IndexMap::from([(CONTENT_TYPE.to_string(), "application/json".to_string())])
+ }
+
+ fn payload(
+ &self,
+ _: &Config,
+ ) -> Payload {
+ Payload {
+ query: None,
+ body: Some(self.body.clone()),
+ }
+ }
+}
+
+fn build_body(
+ context: &Value,
+ record: &TelemetryRecord,
+) -> Value {
+ let mut body = serde_json::to_value(&record.event).unwrap_or_else(|_| Value::Object(Default::default()));
+ if let Value::Object(map) = &mut body {
+ map.insert("event_time".to_string(), Value::String(record.event_time.clone()));
+ map.insert("device".to_string(), context.clone());
+ }
+ body
+}
+
+#[cfg(test)]
+mod tests {
+ use serde_json::json;
+
+ use super::{super::record::TelemetryRecord, build_body};
+ use crate::telemetry::TelemetryEvent;
+
+ #[test]
+ fn build_body_nests_event_time_device_and_payload() {
+ let device = json!({ "os_name": "macOS" });
+ let record = TelemetryRecord {
+ event_time: "2026-06-04T16:24:29Z".to_string(),
+ event: TelemetryEvent::ModelInferenceFinished {
+ model_id: "model-1".to_string(),
+ stats: Default::default(),
+ },
+ };
+ let body = build_body(&device, &record);
+ assert_eq!(body["event_name"], json!("model_inference_finished"));
+ assert_eq!(body["event_time"], json!("2026-06-04T16:24:29Z"));
+ assert_eq!(body["device"]["os_name"], json!("macOS"));
+ assert_eq!(body["payload"]["model_id"], json!("model-1"));
+ assert!(body["payload"]["stats"].is_object());
+ }
+
+ #[test]
+ fn build_body_wraps_failure_error() {
+ let record = TelemetryRecord {
+ event_time: "2026-06-04T16:24:29Z".to_string(),
+ event: TelemetryEvent::ModelInferenceFailed {
+ error: json!({ "message": "boom" }),
+ },
+ };
+ let body = build_body(&json!({}), &record);
+ assert_eq!(body["event_name"], json!("model_inference_failed"));
+ assert_eq!(body["payload"]["error"]["message"], json!("boom"));
+ }
+}
diff --git a/crates/nagare/src/telemetry/event.rs b/crates/nagare/src/telemetry/event.rs
new file mode 100644
index 000000000..b694d1202
--- /dev/null
+++ b/crates/nagare/src/telemetry/event.rs
@@ -0,0 +1,24 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use shoji::types::session::chat::ChatReplyStats;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "event_name", content = "payload", rename_all = "snake_case")]
+pub enum TelemetryEvent {
+ ModelDownloadStarted {
+ model_id: String,
+ },
+ ModelDownloadFinished {
+ model_id: String,
+ },
+ ModelInferenceStarted {
+ model_id: String,
+ },
+ ModelInferenceFinished {
+ model_id: String,
+ stats: ChatReplyStats,
+ },
+ ModelInferenceFailed {
+ error: Value,
+ },
+}
diff --git a/crates/nagare/src/telemetry/mod.rs b/crates/nagare/src/telemetry/mod.rs
new file mode 100644
index 000000000..16a46f2c9
--- /dev/null
+++ b/crates/nagare/src/telemetry/mod.rs
@@ -0,0 +1,10 @@
+#[cfg(not(target_family = "wasm"))]
+mod endpoint;
+mod event;
+mod record;
+mod telemetry;
+#[cfg(not(target_family = "wasm"))]
+mod worker;
+
+pub use event::TelemetryEvent;
+pub use telemetry::Telemetry;
diff --git a/crates/nagare/src/telemetry/record.rs b/crates/nagare/src/telemetry/record.rs
new file mode 100644
index 000000000..c918505bb
--- /dev/null
+++ b/crates/nagare/src/telemetry/record.rs
@@ -0,0 +1,34 @@
+use super::TelemetryEvent;
+
+pub(super) struct TelemetryRecord {
+ pub(super) event_time: String,
+ pub(super) event: TelemetryEvent,
+}
+
+impl TelemetryRecord {
+ pub(super) fn new(event: TelemetryEvent) -> Self {
+ Self {
+ event_time: now_rfc3339(),
+ event,
+ }
+ }
+}
+
+fn now_rfc3339() -> String {
+ chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::TelemetryRecord;
+ use crate::telemetry::TelemetryEvent;
+
+ #[test]
+ fn new_stamps_rfc3339_utc() {
+ let record = TelemetryRecord::new(TelemetryEvent::ModelDownloadFinished {
+ model_id: "model-1".to_string(),
+ });
+ assert!(record.event_time.ends_with('Z'), "expected Z suffix: {}", record.event_time);
+ assert!(chrono::DateTime::parse_from_rfc3339(&record.event_time).is_ok());
+ }
+}
diff --git a/crates/nagare/src/telemetry/telemetry.rs b/crates/nagare/src/telemetry/telemetry.rs
new file mode 100644
index 000000000..5cdca68b5
--- /dev/null
+++ b/crates/nagare/src/telemetry/telemetry.rs
@@ -0,0 +1,63 @@
+use serde_json::Value;
+use tokio::sync::mpsc;
+#[cfg(not(target_family = "wasm"))]
+use tokio::sync::mpsc::channel as TokioMpscChannel;
+
+use super::{TelemetryEvent, record::TelemetryRecord};
+#[cfg(not(target_family = "wasm"))]
+use crate::api::Client;
+use crate::api::Config;
+
+#[cfg(not(target_family = "wasm"))]
+const CAPACITY: usize = 256;
+
+#[derive(Clone)]
+pub struct Telemetry {
+ sender: Option<mpsc::Sender<TelemetryRecord>>,
+}
+
+impl Telemetry {
+ pub fn disabled() -> Self {
+ Self {
+ sender: None,
+ }
+ }
+
+ #[cfg(not(target_family = "wasm"))]
+ pub fn new(
+ client_config: Config,
+ path: String,
+ context: Value,
+ ) -> Self {
+ let client = match Client::new(client_config) {
+ Ok(client) => client,
+ Err(error) => {
+ tracing::warn!(%error, "telemetry disabled: failed to build client");
+ return Self::disabled();
+ },
+ };
+ let (sender, receiver) = TokioMpscChannel::<TelemetryRecord>(CAPACITY);
+ tokio::spawn(super::worker::run(client, path, context, receiver));
+ Self {
+ sender: Some(sender),
+ }
+ }
+
+ #[cfg(target_family = "wasm")]
+ pub fn new(
+ _client_config: Config,
+ _path: String,
+ _context: Value,
+ ) -> Self {
+ Self::disabled()
+ }
+
+ pub fn report(
+ &self,
+ event: TelemetryEvent,
+ ) {
+ if let Some(sender) = &self.sender {
+ let _ = sender.try_send(TelemetryRecord::new(event));
+ }
+ }
+}
diff --git a/crates/nagare/src/telemetry/worker.rs b/crates/nagare/src/telemetry/worker.rs
new file mode 100644
index 000000000..eb0405dd3
--- /dev/null
+++ b/crates/nagare/src/telemetry/worker.rs
@@ -0,0 +1,99 @@
+use serde_json::Value;
+use tokio::sync::mpsc;
+
+use super::{endpoint::TelemetryEndpoint, record::TelemetryRecord};
+use crate::api::{Client, Error};
+
+const MAX_RETRIES: u32 = 4;
+const BASE_BACKOFF_MS: u64 = 1_000;
+const MAX_BACKOFF_MS: u64 = 16_000;
+
+pub(super) async fn run(
+ client: Client,
+ path: String,
+ context: Value,
+ mut receiver: mpsc::Receiver<TelemetryRecord>,
+) {
+ while let Some(record) = receiver.recv().await {
+ send_with_retry(&client, &path, &context, &record).await;
+ }
+}
+
+#[derive(Debug, PartialEq)]
+enum Disposition {
+ Retry,
+ Drop,
+}
+
+async fn send_with_retry(
+ client: &Client,
+ path: &str,
+ context: &Value,
+ record: &TelemetryRecord,
+) {
+ let endpoint = TelemetryEndpoint::new(path.to_string(), context, record);
+ let mut attempt: u32 = 0;
+ loop {
+ match client.send(&endpoint).await {
+ Ok(()) => return,
+ Err(error) => match classify(&error) {
+ Disposition::Drop => {
+ tracing::warn!(%error, "telemetry event dropped");
+ return;
+ },
+ Disposition::Retry => {
+ if attempt >= MAX_RETRIES {
+ tracing::warn!(%error, attempts = attempt, "telemetry event dropped after retries");
+ return;
+ }
+ tokio::time::sleep(backoff(attempt)).await;
+ attempt += 1;
+ },
+ },
+ }
+ }
+}
+
+fn classify(error: &Error) -> Disposition {
+ match error {
+ Error::Http {
+ code,
+ ..
+ } if *code >= 500 => Disposition::Retry,
+ Error::Http {
+ ..
+ } => Disposition::Drop,
+ Error::Timeout | Error::Network(_) => Disposition::Retry,
+ Error::Decode(_) => Disposition::Drop,
+ }
+}
+
+fn backoff(attempt: u32) -> std::time::Duration {
+ let millis = BASE_BACKOFF_MS.saturating_mul(2u64.saturating_pow(attempt)).min(MAX_BACKOFF_MS);
+ std::time::Duration::from_millis(millis)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{Disposition, classify};
+ use crate::api::Error;
+
+ fn http(code: u16) -> Error {
+ Error::Http {
+ code,
+ body: String::new(),
+ }
+ }
+
+ #[test]
+ fn classify_400_drops_503_retries() {
+ assert_eq!(classify(&http(400)), Disposition::Drop);
+ assert_eq!(classify(&http(404)), Disposition::Drop);
+ assert_eq!(classify(&http(503)), Disposition::Retry);
+ assert_eq!(classify(&http(500)), Disposition::Retry);
+ assert_eq!(classify(&http(502)), Disposition::Retry);
+ assert_eq!(classify(&Error::Timeout), Disposition::Retry);
+ assert_eq!(classify(&Error::Network("x".to_string())), Disposition::Retry);
+ assert_eq!(classify(&Error::Decode("x".to_string())), Disposition::Drop);
+ }
+}
diff --git a/crates/uzu/src/device/mod.rs b/crates/uzu/src/device/mod.rs
index 8e6c0ee57..3989e159d 100644
--- a/crates/uzu/src/device/mod.rs
+++ b/crates/uzu/src/device/mod.rs
@@ -2,7 +2,7 @@ mod error;
mod os;
pub use error::DeviceError;
-pub(crate) use os::home_path;
+pub(crate) use os::{home_path, is_environment_sandboxed};
use serde::{Deserialize, Serialize};
use sysinfo::System;
diff --git a/crates/uzu/src/device/os.rs b/crates/uzu/src/device/os.rs
index 2ffba6db8..a6217d2cc 100644
--- a/crates/uzu/src/device/os.rs
+++ b/crates/uzu/src/device/os.rs
@@ -26,3 +26,16 @@ pub fn home_path() -> Option<PathBuf> {
}
dirs::home_dir()
}
+
+#[allow(unreachable_code)]
+pub fn is_environment_sandboxed() -> bool {
+ #[cfg(target_os = "ios")]
+ {
+ return true;
+ }
+ #[cfg(target_os = "macos")]
+ {
+ return std::env::var_os("APP_SANDBOX_CONTAINER_ID").is_some();
+ }
+ false
+}
diff --git a/crates/uzu/src/engine/mod.rs b/crates/uzu/src/engine/mod.rs
index f95e5790b..d2a7520ac 100644
--- a/crates/uzu/src/engine/mod.rs
+++ b/crates/uzu/src/engine/mod.rs
@@ -4,7 +4,7 @@ mod download_manager;
mod downloader;
mod error;
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, sync::Arc, time::Duration};
use backend_remote::openai::Backend as OpenAIBackend;
use backend_uzu::inference::Backend as UzuBackend;
@@ -13,8 +13,14 @@ pub use config::EngineConfig;
pub use download_manager::DownloadManagerType;
pub use downloader::{Downloader, DownloaderStream, DownloaderStreamUpdate};
pub use error::EngineError;
-use indexmap::IndexSet;
-use nagare::{chat::ChatSession, classification::ClassificationSession, text_to_speech::TextToSpeechSession};
+use indexmap::{IndexMap, IndexSet};
+use nagare::{
+ api::Config as ClientConfig,
+ chat::ChatSession,
+ classification::ClassificationSession,
+ telemetry::{Telemetry, TelemetryEvent},
+ text_to_speech::TextToSpeechSession,
+};
use shoji::{
traits::{Backend, Registry},
types::{
@@ -50,6 +56,7 @@ pub struct Engine {
storage: SharedAccess<Storage>,
backends: SharedAccess<HashMap<String, Arc<dyn Backend>>>,
callback: SharedAccess<Option<Arc<EngineCallback>>>,
+ telemetry: SharedAccess<Telemetry>,
}
impl Engine {
@@ -69,6 +76,22 @@ impl Engine {
}
let device = Device::new()?;
+
+ let telemetry = SharedAccess::new({
+ let client_config = ClientConfig::new(
+ "https://sdk.trymirai.com/api/v1".to_string(),
+ Duration::from_secs(10),
+ IndexMap::new(),
+ );
+ let context = serde_json::json!({
+ "os_name": device.os_name,
+ "cpu_name": device.cpu_name,
+ "memory_total": device.memory_total,
+ "is_environment_sandboxed": crate::device::is_environment_sandboxed(),
+ });
+ Telemetry::new(client_config, "telemetry/events".to_string(), context)
+ });
+
let registry = SharedAccess::new(MergedRegistry::new(vec![]));
let storage_config = StorageConfig::new(device.clone(), None, "mirai".to_string())
.with_download_manager_type(config.download_manager_type.into());
@@ -82,6 +105,7 @@ impl Engine {
registry,
backends: SharedAccess::new(HashMap::new()),
callback: SharedAccess::new(None),
+ telemetry,
};
engine.spawn_storage_listener().await;
@@ -460,7 +484,8 @@ impl Engine {
if let Some(backend) = model.backends.first() {
let backends = self.backends.lock().await;
let backend = backends.get(&backend.identifier).ok_or(EngineError::BackendNotFound {})?;
- let session = ChatSession::new(backend.clone(), config, model, path).await?;
+ let session =
+ ChatSession::new(backend.clone(), config, model, path, self.telemetry.lock().await.clone()).await?;
Ok(session)
} else {
Err(EngineError::BackendNotFound {})
@@ -525,10 +550,29 @@ impl Engine {
async fn spawn_storage_listener(&self) {
let mut stream = self.storage_subscribe().await;
let callback = self.callback.clone();
+ let telemetry = self.telemetry.lock().await.clone();
tokio::spawn(async move {
+ let mut last_phase: HashMap<String, DownloadPhase> = HashMap::new();
while let Some(update) = stream.next().await {
- if update.is_err() {
+ let Ok((id, state)) = update else {
continue;
+ };
+ let previous = last_phase.insert(id.clone(), state.phase.clone());
+ let event = match (&previous, &state.phase) {
+ (prev, DownloadPhase::Downloading {}) if !matches!(prev, Some(DownloadPhase::Downloading {})) => {
+ Some(TelemetryEvent::ModelDownloadStarted {
+ model_id: id,
+ })
+ },
+ (Some(DownloadPhase::Downloading {}), DownloadPhase::Downloaded {}) => {
+ Some(TelemetryEvent::ModelDownloadFinished {
+ model_id: id,
+ })
+ },
+ _ => None,
+ };
+ if let Some(event) = event {
+ telemetry.report(event);
}
if let Some(callback) = callback.lock().await.as_ref().cloned() {
callback.on_event();