langfuse-sdk 0.1.1

Langfuse SDK for Rust — LLM observability, prompt management, and evaluation
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use langfuse::scoring::manager::ScoreManager;
use langfuse::scoring::queue::BatchQueue;
use langfuse_core::config::LangfuseConfig;
use langfuse_core::types::{ScoreBody, ScoreValue};

// ── Helpers ──────────────────────────────────────────────────────────────

fn make_score(name: &str, value: ScoreValue) -> ScoreBody {
    ScoreBody {
        name: name.to_string(),
        value,
        trace_id: None,
        observation_id: None,
        comment: None,
        metadata: None,
        config_id: None,
        data_type: None,
    }
}

fn test_config() -> LangfuseConfig {
    LangfuseConfig::builder()
        .public_key("pk-test")
        .secret_key("sk-test")
        .build()
        .unwrap()
}

// ── BatchQueue tests ─────────────────────────────────────────────────────

#[test]
fn test_batch_queue_push_and_drain() {
    let queue = BatchQueue::new(100);
    let score = make_score("accuracy", ScoreValue::Numeric(0.9));

    let full = queue.push(score);
    assert!(!full, "queue should not be full after one push");
    assert_eq!(queue.len(), 1);

    let drained = queue.drain();
    assert_eq!(drained.len(), 1);
    assert_eq!(drained[0].name, "accuracy");
    assert!(queue.is_empty());
}

#[test]
fn test_batch_queue_max_size_signals_full() {
    let queue = BatchQueue::new(2);

    let full1 = queue.push(make_score("s1", ScoreValue::Numeric(1.0)));
    assert!(!full1);

    let full2 = queue.push(make_score("s2", ScoreValue::Numeric(2.0)));
    assert!(full2, "queue should signal full when reaching max_size");
}

#[test]
fn test_batch_queue_drain_empties_buffer() {
    let queue = BatchQueue::new(10);
    queue.push(make_score("a", ScoreValue::Boolean(true)));
    queue.push(make_score("b", ScoreValue::Categorical("good".into())));

    assert_eq!(queue.len(), 2);
    let drained = queue.drain();
    assert_eq!(drained.len(), 2);
    assert_eq!(queue.len(), 0);
    assert!(queue.is_empty());

    // Drain again should return empty
    let drained2 = queue.drain();
    assert!(drained2.is_empty());
}

#[test]
fn test_batch_queue_len_and_is_empty() {
    let queue = BatchQueue::new(10);
    assert!(queue.is_empty());
    assert_eq!(queue.len(), 0);

    queue.push(make_score("x", ScoreValue::Numeric(0.5)));
    assert!(!queue.is_empty());
    assert_eq!(queue.len(), 1);
}

// ── ScoreManager tests ──────────────────────────────────────────────────

#[tokio::test]
async fn test_score_manager_buffers_scores() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    manager.score(make_score("raw", ScoreValue::Numeric(0.8)));
    manager.score_trace("trace-1", "accuracy", ScoreValue::Numeric(0.95));
    manager.score_observation(
        "trace-1",
        "obs-1",
        "quality",
        ScoreValue::Categorical("good".into()),
    );

    assert_eq!(manager.pending_count(), 3);
}

#[tokio::test]
async fn test_score_trace_sets_trace_id() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    manager.score_trace("trace-abc", "relevance", ScoreValue::Numeric(0.7));
    assert_eq!(manager.pending_count(), 1);
}

#[tokio::test]
async fn test_score_observation_sets_both_ids() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    manager.score_observation(
        "trace-abc",
        "obs-xyz",
        "helpfulness",
        ScoreValue::Boolean(true),
    );
    assert_eq!(manager.pending_count(), 1);
}

#[tokio::test]
async fn test_score_manager_flush_empty() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    // Flushing with no scores should succeed (no network call made)
    let result = manager.flush().await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_score_manager_flush_clears_buffer() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    manager.score(make_score("test", ScoreValue::Numeric(1.0)));
    assert_eq!(manager.pending_count(), 1);

    // Flush will fail (no real server), but buffer should be drained
    let _result = manager.flush().await;
    assert_eq!(manager.pending_count(), 0);
}

#[tokio::test]
async fn test_score_manager_shutdown_flushes() {
    let config = test_config();
    let manager = ScoreManager::new(&config);

    // Shutdown with empty buffer should succeed
    let result = manager.shutdown().await;
    assert!(result.is_ok());
}