Collect stats from certificates

TODO: get base64_certificate and issuer_certificate_id

Author: sax

src/dtls_transport/mod.rs

@@ -18,6 +18,7 @@ use tokio::sync::{mpsc, Mutex};
 use util::Conn;
 
 use dtls_role::*;
+use waitgroup::Worker;
 
 use crate::api::setting_engine::SettingEngine;
 use crate::dtls_transport::dtls_parameters::DTLSParameters;
@@ -30,6 +31,7 @@ use crate::mux::endpoint::Endpoint;
 use crate::mux::mux_func::{match_dtls, match_srtcp, match_srtp, MatchFunc};
 use crate::peer_connection::certificate::RTCCertificate;
 use crate::rtp_transceiver::SSRC;
+use crate::stats::stats_collector::StatsCollector;
 
 #[cfg(test)]
 mod dtls_transport_test;
@@ -305,6 +307,16 @@ impl RTCDtlsTransport {
         DEFAULT_DTLS_ROLE_ANSWER
     }
 
+    pub(crate) async fn collect_stats(
+        &self,
+        collector: &Arc<Mutex<StatsCollector>>,
+        worker: Worker,
+    ) {
+        for cert in &self.certificates {
+            cert.collect_stats(&collector, worker.clone()).await;
+        }
+    }
+
     async fn prepare_transport(
         &self,
         remote_parameters: DTLSParameters,

src/peer_connection/certificate.rs

@@ -1,13 +1,19 @@
 use crate::dtls_transport::dtls_fingerprint::RTCDtlsFingerprint;
 use crate::error::{Error, Result};
 use crate::peer_connection::math_rand_alpha;
+use crate::stats::{CertificateStats, StatsReportType};
+use crate::stats::stats_collector::StatsCollector;
 
 use dtls::crypto::{CryptoPrivateKey, CryptoPrivateKeyKind};
 use rcgen::{CertificateParams, KeyPair, RcgenError};
 use ring::signature::{EcdsaKeyPair, Ed25519KeyPair, RsaKeyPair};
 use sha2::{Digest, Sha256};
+use tokio::time::Instant;
 use std::ops::Add;
+use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tokio::sync::Mutex;
+use waitgroup::Worker;
 
 /// Certificate represents a x509Cert used to authenticate WebRTC communications.
 pub struct RTCCertificate {
@@ -161,6 +167,29 @@ impl RTCCertificate {
         RTCCertificate::from_params(params)
     }
 
+    pub(crate) async fn collect_stats(
+        &self,
+        collector: &Arc<Mutex<StatsCollector>>,
+        worker: Worker,
+    ) {
+        let fingerprints = self.get_fingerprints().unwrap();
+        if let Some(fingerprint) = fingerprints.into_iter().nth(0) {
+            let stats = CertificateStats {
+                timestamp: Instant::now(),
+                id: self.stats_id.clone(),
+                // base64_certificate
+                fingerprint: fingerprint.value,
+                fingerprint_algorithm: fingerprint.algorithm,
+                // issuer_certificate_id
+
+            };
+            let mut lock = collector.try_lock().unwrap();
+            lock.push(StatsReportType::CertificateStats(stats));
+
+            drop(worker);
+        }
+    }
+
     /*TODO:
     // CertificateFromX509 creates a new WebRTC Certificate from a given PrivateKey and Certificate
     //

src/peer_connection/peer_connection_internal.rs

@@ -1327,6 +1327,9 @@ impl PeerConnectionInternal {
             self.ice_gatherer.collect_stats(&collector, wg.worker()),
             self.ice_transport.collect_stats(&collector, wg.worker()),
             self.sctp_transport.collect_stats(&collector, wg.worker()),
+            self.dtls_transport.collect_stats(&collector, wg.worker()),
+            // TODO: data channels
+            // TODO: media engine
         );
 
         wg.wait().await;

src/stats/mod.rs

@@ -17,6 +17,7 @@ pub enum SourceStatsType {
 
 pub enum StatsReportType {
     CandidatePair(ICECandidatePairStats),
+    CertificateStats(CertificateStats),
     LocalCandidate(ICECandidateStats),
     RemoteCandidate(ICECandidateStats),
     SCTPTransport(ICETransportStats),
@@ -150,8 +151,18 @@ pub struct ICETransportStats {
 impl ICETransportStats {
     pub(crate) fn new(id: String) -> Self {
         ICETransportStats {
+            id,
             timestamp: Instant::now(),
-            id: id,
         }
     }
 }
+
+pub struct CertificateStats {
+    pub timestamp: Instant,
+    pub id: String,
+    // base64_certificate: String,
+    pub fingerprint: String,
+    pub fingerprint_algorithm: String,
+    // issuer_certificate_id: String,
+}
+