sova-grpc 0.1.2

Connect-JSON unary RPC client (+ optional server) for Sova
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

//! DevTools tracing (`target: "sova.grpc"`).

use crate::error::GrpcError;

pub(crate) struct Emit<'a> {
    pub direction: &'a str,
    pub method: &'a str,
    pub base: &'a str,
    pub duration_ms: f64,
    pub ok: bool,
    pub status: Option<u16>,
    pub error: Option<String>,
    pub bytes_in: Option<u64>,
    pub bytes_out: Option<u64>,
}

pub(crate) fn emit(e: Emit<'_>) {
    tracing::debug!(
        target: "sova.grpc",
        direction = e.direction,
        method = %e.method,
        base = %e.base,
        duration_ms = e.duration_ms,
        ok = e.ok,
        status = e.status,
        error = e.error.as_deref(),
        bytes_in = e.bytes_in,
        bytes_out = e.bytes_out,
    );
}

pub(crate) fn emit_client(
    method: &str,
    base: &str,
    duration_ms: f64,
    result: &Result<bytes::Bytes, GrpcError>,
    bytes_in: u64,
) {
    match result {
        Ok(out) => emit(Emit {
            direction: "client",
            method,
            base,
            duration_ms,
            ok: true,
            status: Some(200),
            error: None,
            bytes_in: Some(bytes_in),
            bytes_out: Some(out.len() as u64),
        }),
        Err(e) => {
            let (status, msg) = error_meta(e);
            emit(Emit {
                direction: "client",
                method,
                base,
                duration_ms,
                ok: false,
                status,
                error: Some(msg),
                bytes_in: Some(bytes_in),
                bytes_out: None,
            });
        }
    }
}

pub(crate) fn emit_server(
    method: &str,
    duration_ms: f64,
    result: &Result<bytes::Bytes, GrpcError>,
    bytes_in: u64,
) {
    match result {
        Ok(out) => emit(Emit {
            direction: "server",
            method,
            base: "in-process",
            duration_ms,
            ok: true,
            status: Some(200),
            error: None,
            bytes_in: Some(bytes_in),
            bytes_out: Some(out.len() as u64),
        }),
        Err(e) => {
            let (status, msg) = error_meta(e);
            emit(Emit {
                direction: "server",
                method,
                base: "in-process",
                duration_ms,
                ok: false,
                status,
                error: Some(msg),
                bytes_in: Some(bytes_in),
                bytes_out: None,
            });
        }
    }
}

fn error_meta(err: &GrpcError) -> (Option<u16>, String) {
    match err {
        GrpcError::Http { status, body } => (Some(*status), body.clone()),
        GrpcError::Rpc { code, message } => (None, format!("{code}: {message}")),
        other => (None, other.to_string()),
    }
}