easybill / serverdensity-udp-agent Goto Github PK

Bitte auf https://packagist.org/packages/submit
Die Url https://github.com/easybill/serverdensity-udp-agent eintragen.

mir fehlen leider die Berechtigungen ;)

Im Moment kommt immer Prometheus UDP Monitor 2.0 - das sollte stattdessen zB v0.6.4 sein.

Der Code verwendet aktuell blocking code wie thread::sleep und gleichzeitig tokio. Es passieren schlimme dinge, wenn man in einer async runtime wie tokio blocking code ausführt - muss überall ausgebaut werden.

Achtung:
Es ist nicht nur das thread::sleep, du darfst auch crossbeam nicht verwenden.
Du kannst auch alternativ auf threads umstellen und tokio nicht verwenden. siehe crossbeam-rs/crossbeam#501 .

dieser code blockt nen kompletten tokio thread und damit evtl. die komplette runtime.

loop {
            match receiver.recv(); // crossbeam_channel::Receiver.recv()
}

auch sowas blockt:

let mut res = self
            .http_client
            .post(&self.api_postback_uri)
            .header("X-Forwarded-Host", self.config.account_url.clone())
            .form(data)
            .timeout(Duration::from_secs(30))
            .send(); // <<< blocking

^ du kannst auch genre auf async verzichten wenns zu viel ist.

Aktuell gibt es im code noch unwraps, diese müssen alle entfernt werden.
Zudem muss alles, was in einem Task läuft unfailbar sein (startet im zweifel neu und probiert es erneut).

Wenn z.b. der Processor failed muss das geloggt werden und er muss wieder neu gestartet werden.
Die run Methode kann z.b. so aussehen:

pub async fn run(&mut self, receiver: Receiver<InboundMetric>) -> anyhow::Result<(), anyhow::Error> {
    loop {
        match self
            .run_inner(receiver.clone()) {
            Ok(_) => {},
            Err(e) => {
                error!("XXX failed: {:?}", e)
            }
        };
    
        // es ist wichtig, dass wir dem prozess etwas zeit lassen. Sonst haste schnell TB an logs :P
        ::tokio::time::sleep(Duration::from_secs(1)).await;
    }
}

in der main function bitte nicht einfach tasks nach dem muster fire&forget spawnen, sondern mit einem select! alle tasks monitoren.

tokio::spawn(||{ loop { /** ... */ } });
tokio::spawn(||{ loop { /** ... */ } }).await;

bitte

let jh1 = tokio::spawn(||{ loop { /** ... */ } });
let jh2 = tokio::spawn(||{ loop { /** ... */ } });

select! {
  _ => jh1 { error!("1 failed"); }
 _ => jh2 { error!("2 failed"); }
}

Oft knallt z.b. ein prozess (panic) und du bekommst es nicht mit, dann hängt ein anderer (oder knallt) weil du ein ende einer queue kaputt gemacht hast. Wenn ein prozess (async task) der lange laufen muss, kaputt geht, müssen wir das mitbekommen.