wlan_telemetry/
lib.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4use anyhow::{format_err, Context as _, Error};
5use fuchsia_inspect::Node as InspectNode;
6use futures::channel::mpsc;
7use futures::{future, select, Future, StreamExt, TryFutureExt};
8use log::error;
9use std::boxed::Box;
10use windowed_stats::experimental::serve::serve_time_matrix_inspection;
11use wlan_common::bss::BssDescription;
12use {
13    fidl_fuchsia_power_battery as fidl_battery, fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211,
14    fuchsia_async as fasync, fuchsia_inspect_auto_persist as auto_persist,
15    wlan_legacy_metrics_registry as metrics,
16};
17
18mod processors;
19pub(crate) mod util;
20pub use crate::processors::connect_disconnect::DisconnectInfo;
21pub use crate::processors::power::{IfacePowerLevel, UnclearPowerDemand};
22pub use crate::processors::scan::ScanResult;
23pub use crate::processors::toggle_events::ClientConnectionsToggleEvent;
24pub use util::sender::TelemetrySender;
25#[cfg(test)]
26mod testing;
27
28#[derive(Debug)]
29pub enum TelemetryEvent {
30    ConnectResult {
31        result: fidl_ieee80211::StatusCode,
32        bss: Box<BssDescription>,
33    },
34    Disconnect {
35        info: DisconnectInfo,
36    },
37    // We should maintain docstrings if we can see any possibility of ambiguity for an enum
38    /// Client connections enabled or disabled
39    ClientConnectionsToggle {
40        event: ClientConnectionsToggleEvent,
41    },
42    ClientIfaceCreated {
43        iface_id: u16,
44    },
45    ClientIfaceDestroyed {
46        iface_id: u16,
47    },
48    ScanStart,
49    ScanResult {
50        result: ScanResult,
51    },
52    IfacePowerLevelChanged {
53        iface_power_level: IfacePowerLevel,
54        iface_id: u16,
55    },
56    /// System suspension imminent
57    SuspendImminent,
58    /// Unclear power level requested by policy layer
59    UnclearPowerDemand(UnclearPowerDemand),
60    BatteryChargeStatus(fidl_battery::ChargeStatus),
61    RecoveryEvent,
62}
63
64/// Attempts to connect to the Cobalt service.
65pub async fn setup_cobalt_proxy(
66) -> Result<fidl_fuchsia_metrics::MetricEventLoggerProxy, anyhow::Error> {
67    let cobalt_svc = fuchsia_component::client::connect_to_protocol::<
68        fidl_fuchsia_metrics::MetricEventLoggerFactoryMarker,
69    >()
70    .context("failed to connect to metrics service")?;
71
72    let (cobalt_proxy, cobalt_server) =
73        fidl::endpoints::create_proxy::<fidl_fuchsia_metrics::MetricEventLoggerMarker>();
74
75    let project_spec = fidl_fuchsia_metrics::ProjectSpec {
76        customer_id: Some(metrics::CUSTOMER_ID),
77        project_id: Some(metrics::PROJECT_ID),
78        ..Default::default()
79    };
80
81    match cobalt_svc.create_metric_event_logger(&project_spec, cobalt_server).await {
82        Ok(_) => Ok(cobalt_proxy),
83        Err(err) => Err(format_err!("failed to create metrics event logger: {:?}", err)),
84    }
85}
86
87/// Attempts to create a disconnected FIDL channel with types matching the Cobalt service. This
88/// allows for a fallback with a uniform code path in case of a failure to connect to Cobalt.
89pub fn setup_disconnected_cobalt_proxy(
90) -> Result<fidl_fuchsia_metrics::MetricEventLoggerProxy, anyhow::Error> {
91    // Create a disconnected proxy
92    Ok(fidl::endpoints::create_proxy::<fidl_fuchsia_metrics::MetricEventLoggerMarker>().0)
93}
94
95pub fn setup_persistence_req_sender(
96) -> Result<(auto_persist::PersistenceReqSender, impl Future<Output = ()>), anyhow::Error> {
97    fuchsia_component::client::connect_to_protocol::<
98        fidl_fuchsia_diagnostics_persist::DataPersistenceMarker,
99    >()
100    .map(auto_persist::create_persistence_req_sender)
101}
102
103/// Creates a disconnected channel with the same types as the persistence service. This allows for
104/// a fallback with a uniform code path in case of a failure to connect to the persistence service.
105pub fn setup_disconnected_persistence_req_sender() -> auto_persist::PersistenceReqSender {
106    let (sender, _receiver) = mpsc::channel::<String>(1);
107    // Note: because we drop the receiver here, be careful about log spam when sending
108    // tags through the `sender` below. This is automatically handled by `auto_persist::AutoPersist`
109    // because it only logs the first time sending fails, so just use that wrapper type instead of
110    // writing directly to this channel.
111    sender
112}
113
114/// How often to refresh time series stats. Also how often to request packet counters.
115const TELEMETRY_QUERY_INTERVAL: zx::MonotonicDuration = zx::MonotonicDuration::from_seconds(10);
116
117pub fn serve_telemetry(
118    cobalt_proxy: fidl_fuchsia_metrics::MetricEventLoggerProxy,
119    monitor_svc_proxy: fidl_fuchsia_wlan_device_service::DeviceMonitorProxy,
120    inspect_node: InspectNode,
121    inspect_path: &str,
122    persistence_req_sender: auto_persist::PersistenceReqSender,
123) -> (TelemetrySender, impl Future<Output = Result<(), Error>>) {
124    let (sender, mut receiver) =
125        mpsc::channel::<TelemetryEvent>(util::sender::TELEMETRY_EVENT_BUFFER_SIZE);
126    let sender = TelemetrySender::new(sender);
127
128    // Inspect nodes to hold time series and metadata for other nodes
129    const METADATA_NODE_NAME: &str = "metadata";
130    let inspect_metadata_node = inspect_node.create_child(METADATA_NODE_NAME);
131    let inspect_time_series_node = inspect_node.create_child("time_series");
132    let driver_specific_time_series_node = inspect_time_series_node.create_child("driver_specific");
133    let driver_counters_time_series_node =
134        driver_specific_time_series_node.create_child("counters");
135    let driver_gauges_time_series_node = driver_specific_time_series_node.create_child("gauges");
136
137    let (time_matrix_client, time_series_fut) =
138        serve_time_matrix_inspection(inspect_time_series_node);
139    let (driver_counters_time_series_client, driver_counters_time_series_fut) =
140        serve_time_matrix_inspection(driver_counters_time_series_node);
141    let (driver_gauges_time_series_client, driver_gauges_time_series_fut) =
142        serve_time_matrix_inspection(driver_gauges_time_series_node);
143
144    // Create and initialize modules
145    let connect_disconnect = processors::connect_disconnect::ConnectDisconnectLogger::new(
146        cobalt_proxy.clone(),
147        &inspect_node,
148        &inspect_metadata_node,
149        &format!("{inspect_path}/{METADATA_NODE_NAME}"),
150        persistence_req_sender,
151        &time_matrix_client,
152    );
153    let power_logger = processors::power::PowerLogger::new(cobalt_proxy.clone(), &inspect_node);
154    let recovery_logger = processors::recovery::RecoveryLogger::new(cobalt_proxy.clone());
155    let mut scan_logger = processors::scan::ScanLogger::new(cobalt_proxy.clone());
156    let mut toggle_logger =
157        processors::toggle_events::ToggleLogger::new(cobalt_proxy.clone(), &inspect_node);
158
159    let client_iface_counters_logger =
160        processors::client_iface_counters::ClientIfaceCountersLogger::new(
161            cobalt_proxy,
162            monitor_svc_proxy,
163            &time_matrix_client,
164            driver_counters_time_series_client,
165            driver_gauges_time_series_client,
166        );
167
168    let fut = async move {
169        // Prevent the inspect nodes from being dropped while the loop is running.
170        let _inspect_node = inspect_node;
171        let _inspect_metadata_node = inspect_metadata_node;
172        let _driver_specific_time_series_node = driver_specific_time_series_node;
173
174        let mut telemetry_interval = fasync::Interval::new(TELEMETRY_QUERY_INTERVAL);
175        loop {
176            select! {
177                event = receiver.next() => {
178                    let Some(event) = event else {
179                        error!("Telemetry event stream unexpectedly terminated.");
180                        return Err(format_err!("Telemetry event stream unexpectedly terminated."));
181                    };
182                    use TelemetryEvent::*;
183                    match event {
184                        ConnectResult { result, bss } => {
185                            connect_disconnect.handle_connect_attempt(result, &bss).await;
186                        }
187                        Disconnect { info } => {
188                            connect_disconnect.log_disconnect(&info).await;
189                            power_logger.handle_iface_disconnect(info.iface_id).await;
190                        }
191                        ClientConnectionsToggle { event } => {
192                            toggle_logger.handle_toggle_event(event).await;
193                        }
194                        ClientIfaceCreated { iface_id } => {
195                            client_iface_counters_logger.handle_iface_created(iface_id).await;
196                        }
197                        ClientIfaceDestroyed { iface_id } => {
198                            client_iface_counters_logger.handle_iface_destroyed(iface_id).await;
199                            power_logger.handle_iface_destroyed(iface_id).await;
200                        }
201                        ScanStart => {
202                            scan_logger.handle_scan_start().await;
203                        }
204                        ScanResult { result } => {
205                            scan_logger.handle_scan_result(result).await;
206                        }
207                        IfacePowerLevelChanged { iface_power_level, iface_id } => {
208                            power_logger.log_iface_power_event(iface_power_level, iface_id).await;
209                        }
210                        // TODO(b/340921554): either watch for suspension directly in the library,
211                        // or plumb this from callers once suspend mechanisms are integrated
212                        SuspendImminent => {
213                            power_logger.handle_suspend_imminent().await;
214                            connect_disconnect.handle_suspend_imminent().await;
215                        }
216                        UnclearPowerDemand(demand) => {
217                            power_logger.handle_unclear_power_demand(demand).await;
218                        }
219                        BatteryChargeStatus(charge_status) => {
220                            scan_logger.handle_battery_charge_status(charge_status).await;
221                            toggle_logger.handle_battery_charge_status(charge_status).await;
222                        }
223                        RecoveryEvent => {
224                            recovery_logger.handle_recovery_event().await;
225                        }
226                    }
227                }
228                _ = telemetry_interval.next() => {
229                    connect_disconnect.handle_periodic_telemetry().await;
230                    client_iface_counters_logger.handle_periodic_telemetry().await;
231                }
232            }
233        }
234    };
235    let fut = future::try_join4(
236        fut,
237        time_series_fut,
238        driver_counters_time_series_fut,
239        driver_gauges_time_series_fut,
240    )
241    .map_ok(|((), (), (), ())| ());
242    (sender, fut)
243}
wlan_telemetry/lib.rs

wlan_telemetry/
lib.rs
