Update with bandwidth metrics

Taskfile.yml

@@ -2,8 +2,11 @@
 
 version: '3'
 
+env:
+  DOCKER_TAG: "" 
+
 vars:
-  DOCKER_TAG: latest
+  DOCKER_TAG: ${DOCKER_TAG:-latest}
 
 tasks:
   build: 

src/prometheus.rs

@@ -32,6 +32,11 @@ pub enum TaskResult {
     Default,
 }
 
+#[derive(Clone, Hash, Eq, PartialEq, EncodeLabelSet, Debug)]
+struct PlexSessionBandwidth {
+    pub user: String,
+    pub location: String,
+}
 #[derive(Clone, Hash, Eq, PartialEq, EncodeLabelSet, Debug)]
 struct PlexSessionLabels {
     pub name: String,
@@ -431,6 +436,7 @@ fn format_plex_session_metrics(
     let plex_sessions = Family::<PlexSessionLabels, Gauge<f64, AtomicU64>>::default();
     let plex_sessions_percentage =
         Family::<PlexSessionPercentageLabels, Gauge<f64, AtomicU64>>::default();
+    let plex_session_bandwidth = Family::<PlexSessionBandwidth, Gauge<f64, AtomicU64>>::default();
     registry.register(
         "plex_sessions",
         format!("Plex sessions status"),
@@ -441,6 +447,11 @@ fn format_plex_session_metrics(
         format!("Plex sessions percentage status"),
         plex_sessions_percentage.clone(),
     );
+    registry.register(
+        "plex_session_bandwidth",
+        format!("Plex session bandwidth"),
+        plex_session_bandwidth.clone(),
+    );
 
     sessions.into_iter().for_each(|(name, sessions)| {
         sessions.into_iter().for_each(|session| {
@@ -488,6 +499,12 @@ fn format_plex_session_metrics(
                     latitude: session.location.latitude.clone(),
                 })
                 .set(1.0);
+            plex_session_bandwidth
+                .get_or_create(&PlexSessionBandwidth {
+                    user: session.user.clone(),
+                    location: session.bandwidth.location.to_string(),
+                })
+                .set(session.bandwidth.bandwidth as f64);
         });
     });
 }

src/providers/structs/plex.rs

@@ -159,58 +159,27 @@ impl SessionMetadata {
             Some(parent) => parent.to_string(),
             None => self.title.clone(),
         };
-        match &media_type[..] {
-            "episode" => PlexSessions {
-                title,
-                user,
-                stream_decision,
-                media_type,
-                state,
-                progress,
-                quality,
-                season_number,
-                episode_number,
-                location,
-                address,
-                local,
-                secure,
-                relayed,
-                platform,
-            },
-            "movie" => PlexSessions {
-                title,
-                user,
-                stream_decision,
-                media_type,
-                state,
-                progress,
-                quality,
-                season_number: None,
-                episode_number: None,
-                location,
-                address,
-                local,
-                secure,
-                relayed,
-                platform,
-            },
-            _ => PlexSessions {
-                title,
-                user,
-                stream_decision,
-                media_type,
-                state,
-                progress,
-                quality,
-                season_number: None,
-                episode_number: None,
-                location,
-                address,
-                local,
-                secure,
-                relayed,
-                platform,
-            },
+        let bandwidth = Bandwidth {
+            bandwidth: self.session.bandwidth,
+            location: self.session.location.clone().into(),
+        };
+        PlexSessions {
+            title,
+            user,
+            stream_decision,
+            media_type,
+            state,
+            progress,
+            quality,
+            season_number,
+            episode_number,
+            location,
+            address,
+            local,
+            secure,
+            relayed,
+            platform,
+            bandwidth,
         }
     }
 }
@@ -261,6 +230,7 @@ pub struct Player {
 #[serde(rename_all = "camelCase")]
 pub struct Session {
     pub location: String,
+    pub bandwidth: i64,
 }
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Location {
@@ -307,6 +277,36 @@ pub struct PlexSessions {
     pub secure: bool,
     pub relayed: bool,
     pub platform: String,
+    pub bandwidth: Bandwidth,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Bandwidth {
+    pub bandwidth: i64,
+    pub location: BandwidthLocation,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum BandwidthLocation {
+    Wan,
+    Lan,
+}
+impl From<String> for BandwidthLocation {
+    fn from(location: String) -> Self {
+        match location.as_str() {
+            "wan" => BandwidthLocation::Wan,
+            "lan" => BandwidthLocation::Lan,
+            _ => BandwidthLocation::Wan,
+        }
+    }
+}
+impl Display for BandwidthLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BandwidthLocation::Wan => write!(f, "WAN"),
+            BandwidthLocation::Lan => write!(f, "LAN"),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]