fn0 0.2.41

FaaS platform powered by wasmtime
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

use opentelemetry::{KeyValue, global};
use std::time::Duration;

const SECONDS_BUCKETS: [f64; 7] = [0.005, 0.025, 0.1, 0.5, 1.0, 5.0, 30.0];

pub fn wasmtime_error(func: &'static str, error: &str) {
    let counter = global::meter("fn0").u64_counter("wasmtime_error").build();
    counter.add(
        1,
        &[
            KeyValue::new("func", func),
            KeyValue::new("error", error.to_string()),
        ],
    );
}

pub fn oneshot_drop_before_response() {
    let counter = global::meter("fn0")
        .u64_counter("oneshot_drop_before_response")
        .build();
    counter.add(1, &[]);
}

pub fn proxy_returns_error_code(error_code: &str) {
    let counter = global::meter("fn0")
        .u64_counter("proxy_returns_error_code")
        .build();
    counter.add(1, &[KeyValue::new("error_code", error_code.to_string())]);
}

pub fn request_task_join_error(error: &str) {
    let counter = global::meter("fn0")
        .u64_counter("request_task_join_error")
        .build();
    counter.add(1, &[KeyValue::new("error", error.to_string())]);
}

pub fn cpu_time(cpu_time: Duration) {
    let histogram = global::meter("fn0")
        .f64_histogram("cpu_time_seconds")
        .with_boundaries(SECONDS_BUCKETS.to_vec())
        .build();
    histogram.record(cpu_time.as_secs_f64(), &[]);
}

pub fn cpu_timeout(cpu_time: Duration) {
    let counter = global::meter("fn0").u64_counter("cpu_timeout").build();
    counter.add(1, &[]);

    let histogram = global::meter("fn0")
        .f64_histogram("cpu_timeout_seconds")
        .with_boundaries(SECONDS_BUCKETS.to_vec())
        .build();
    histogram.record(cpu_time.as_secs_f64(), &[]);
}

pub fn trapped(trap: &str) {
    let counter = global::meter("fn0").u64_counter("trapped").build();
    counter.add(1, &[KeyValue::new("trap", trap.to_string())]);
}

pub fn canceled_unexpectedly(error: &str) {
    let counter = global::meter("fn0")
        .u64_counter("canceled_unexpectedly")
        .build();
    counter.add(1, &[KeyValue::new("error", error.to_string())]);
}

pub fn create_instance() {
    let counter = global::meter("fn0").u64_counter("create_instance").build();
    counter.add(1, &[]);
}

pub fn proxy_cache_error(error: &str) {
    let counter = global::meter("fn0")
        .u64_counter("proxy_cache_error")
        .build();
    counter.add(1, &[KeyValue::new("error", error.to_string())]);
}

pub fn project_id_parse_error() {
    let counter = global::meter("fn0")
        .u64_counter("project_id_parse_error")
        .build();
    counter.add(1, &[]);
}

pub fn function_invocation() {
    let counter = global::meter("fn0")
        .u64_counter("function_invocation")
        .build();
    counter.add(1, &[]);
}

pub fn execution_time(route: &str, duration: Duration) {
    let histogram = global::meter("fn0")
        .f64_histogram("execution_time_seconds")
        .with_boundaries(SECONDS_BUCKETS.to_vec())
        .build();
    histogram.record(
        duration.as_secs_f64(),
        &[KeyValue::new("route", route.to_string())],
    );
}

pub fn panicked() {
    let counter = global::meter("fn0").u64_counter("panicked").build();
    counter.add(1, &[]);
}

pub fn request_deadline_exceeded() {
    let counter = global::meter("fn0")
        .u64_counter("request_deadline_exceeded")
        .build();
    counter.add(1, &[]);
}

pub fn stage_duration(stage: &'static str, duration: Duration) {
    let histogram = global::meter("fn0")
        .f64_histogram("stage_duration_seconds")
        .with_boundaries(SECONDS_BUCKETS.to_vec())
        .build();
    histogram.record(duration.as_secs_f64(), &[KeyValue::new("stage", stage)]);
}