shors 0.13.0

Transport layer for cartridge + tarantool-module projects.
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

use crate::tarantool::tlua;
use crate::tarantool::tlua::PushGuard;
use crate::tarantool::tlua::{TuplePushError, Void};
use crate::tarantool::tuple::Encode;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fmt::Debug;
use std::sync::Arc;

#[macro_use]
pub mod http;
pub mod rpc;

/// Context useful for store metadata (like request id) through request path in distributed system.
/// Features like tracing require context for for forwarding trace metadata between instances.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Context {
    data: HashMap<String, Arc<String>>,
}

impl Context {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self {
            data: HashMap::default(),
        }
    }

    /// Create background context - with random generated request_id.
    pub fn background() -> Self {
        Self {
            data: HashMap::from([(
                "request_id".to_string(),
                Arc::new(format!(
                    "background {}",
                    crate::tarantool::uuid::Uuid::random(),
                )),
            )]),
        }
    }

    pub fn put(&mut self, key: impl Into<String>, value: impl Into<String>) {
        self.data.insert(key.into(), Arc::new(value.into()));
    }

    pub fn get(&self, key: &str) -> Option<&str> {
        self.data.get(key).map(|val| val.as_str())
    }

    pub fn endpoint_path(&self) -> &str {
        self.data
            .get("path")
            .map(|s| s.as_str())
            .unwrap_or("unknown")
    }

    pub fn enable_tracing(&mut self) {
        self.put("tracing", "on")
    }

    pub fn tracing_enabled(&self) -> bool {
        self.get("tracing").map(|v| v == "on").unwrap_or(false)
    }
}

impl Encode for Context {}

impl<L> tlua::Push<L> for Context
where
    L: tlua::AsLua + Debug,
{
    type Err = TuplePushError<Void, TuplePushError<Void, Void>>;

    fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)> {
        HashMap::from([(
            "data",
            self.data
                .iter()
                .map(|(k, v)| (k.as_str(), v.as_str()))
                .collect::<HashMap<_, _>>(),
        )])
        .push_to_lua(lua)
    }
}

impl<L> tlua::PushOne<L> for Context where L: tlua::AsLua + Debug {}

mod otel {
    use super::Context;
    use opentelemetry::propagation::{Extractor, Injector};
    use opentelemetry::{global, Context as OTELContext};

    impl Injector for Context {
        fn set(&mut self, key: &str, value: String) {
            self.put(key, value);
        }
    }

    impl Extractor for Context {
        fn get(&self, key: &str) -> Option<&str> {
            self.get(key)
        }

        fn keys(&self) -> Vec<&str> {
            self.data.keys().map(|k| k.as_str()).collect()
        }
    }

    impl Context {
        pub fn inject(&mut self, ctx: &OTELContext) {
            global::get_text_map_propagator(|propagator| {
                propagator.inject_context(ctx, self);
            });
        }

        pub fn extract(&self) -> OTELContext {
            global::get_text_map_propagator(|propagator| propagator.extract(self))
        }
    }
}