unleash-edge 19.8.2

Unleash edge is a proxy for Unleash. It can return both evaluated feature toggles as well as the raw data from Unleash's client API
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

use base64::Engine;
use prometheus_reqwest_remote_write::WriteRequest;
use reqwest::{Client, header};
use tracing::debug;

fn get_http_client(username: Option<String>, password: Option<String>) -> Client {
    if let Some(uname) = username.clone() {
        let mut headers = header::HeaderMap::new();
        let mut value = header::HeaderValue::from_str(&format!(
            "Basic {}",
            base64::engine::general_purpose::STANDARD.encode(format!(
                "{}:{}",
                uname,
                password.clone().unwrap_or_default()
            ))
        ))
        .expect("Could not create header");
        value.set_sensitive(true);
        headers.insert(header::AUTHORIZATION, value);
        reqwest::Client::builder()
            .default_headers(headers)
            .build()
            .expect("Could not build client")
    } else {
        reqwest::Client::new()
    }
}

pub async fn prometheus_remote_write(
    registry: prometheus::Registry,
    url: Option<String>,
    interval: u64,
    username: Option<String>,
    password: Option<String>,
    app_name: String,
) {
    let sleep_duration = tokio::time::Duration::from_secs(interval);
    let client = get_http_client(username, password);
    if let Some(address) = url {
        loop {
            tokio::select! {
                _ = tokio::time::sleep(sleep_duration) => {
                    remote_write_prom(registry.clone(), address.clone(), client.clone(), app_name.clone()).await;
                }
            }
        }
    } else {
        loop {
            tokio::select! {
                _ = tokio::time::sleep(sleep_duration) => {
                }
            }
        }
    }
}

async fn remote_write_prom(
    registry: prometheus::Registry,
    url: String,
    client: reqwest::Client,
    app_name: String,
) {
    let write_request = WriteRequest::from_metric_families(
        registry.gather(),
        Some(vec![("app_name".into(), app_name)]),
    )
    .expect("Could not format write request");
    let http_request = write_request
        .build_http_request(client.clone(), &url, "unleash_edge")
        .expect("Failed to build http request");

    match client.execute(http_request).await {
        Ok(r) => {
            if !r.status().is_success() {
                tracing::warn!("Prometheus push failed with status: {}", r.status());
            }
            debug!("Prometheus push successful");
        }
        Err(e) => {
            tracing::warn!("Prometheus push failed with error: {:?}", e);
        }
    }
}