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

use langfuse::{LangfuseSpan, ScoreBody, ScoreDataType, ScoreValue};

#[test]
fn test_score_body_builder_required_fields_only() {
    let body = ScoreBody::builder("accuracy", ScoreValue::Numeric(0.95)).build();

    assert_eq!(body.name, "accuracy");
    assert_eq!(body.value, ScoreValue::Numeric(0.95));
    assert!(body.trace_id.is_none());
    assert!(body.observation_id.is_none());
    assert!(body.comment.is_none());
    assert!(body.metadata.is_none());
    assert!(body.config_id.is_none());
    assert!(body.data_type.is_none());
}

#[test]
fn test_score_body_builder_all_optional_fields() {
    let metadata = serde_json::json!({"source": "test"});
    let body = ScoreBody::builder("quality", ScoreValue::Boolean(true))
        .trace_id("trace-123")
        .observation_id("obs-456")
        .comment("Excellent quality")
        .metadata(metadata.clone())
        .config_id("cfg-789")
        .data_type(ScoreDataType::Boolean)
        .build();

    assert_eq!(body.name, "quality");
    assert_eq!(body.value, ScoreValue::Boolean(true));
    assert_eq!(body.trace_id.as_deref(), Some("trace-123"));
    assert_eq!(body.observation_id.as_deref(), Some("obs-456"));
    assert_eq!(body.comment.as_deref(), Some("Excellent quality"));
    assert_eq!(body.metadata, Some(metadata));
    assert_eq!(body.config_id.as_deref(), Some("cfg-789"));
    assert_eq!(body.data_type, Some(ScoreDataType::Boolean));
}

#[test]
fn test_score_body_builder_categorical_value() {
    let body = ScoreBody::builder("sentiment", ScoreValue::Categorical("positive".into())).build();

    assert_eq!(body.name, "sentiment");
    assert_eq!(body.value, ScoreValue::Categorical("positive".to_string()));
}

#[tokio::test]
async fn test_span_score_returns_error_without_singleton() {
    // Without Langfuse::init(), scoring methods should return an error
    // because the global singleton is not available.
    let span = LangfuseSpan::start("test-span");
    let result = span.score("quality", ScoreValue::Numeric(0.9));
    assert!(result.is_err());
    span.end();
}

#[tokio::test]
async fn test_span_score_with_returns_error_without_singleton() {
    let span = LangfuseSpan::start("test-span");
    let body = ScoreBody::builder("quality", ScoreValue::Numeric(0.9))
        .comment("test comment")
        .build();
    let result = span.score_with(body);
    assert!(result.is_err());
    span.end();
}

#[tokio::test]
async fn test_span_score_trace_returns_error_without_singleton() {
    let span = LangfuseSpan::start("test-span");
    let result = span.score_trace("accuracy", ScoreValue::Numeric(0.8));
    assert!(result.is_err());
    span.end();
}