1use 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 ClientConnectionsToggle {
40 event: ClientConnectionsToggleEvent,
41 },
42 ClientIfaceCreated {
43 iface_id: u16,
44 },
45 ClientIfaceDestroyed {
46 iface_id: u16,
47 },
48 IfaceCreationFailure,
49 IfaceDestructionFailure,
50 ScanStart,
51 ScanResult {
52 result: ScanResult,
53 },
54 IfacePowerLevelChanged {
55 iface_power_level: IfacePowerLevel,
56 iface_id: u16,
57 },
58 SuspendImminent,
60 UnclearPowerDemand(UnclearPowerDemand),
62 BatteryChargeStatus(fidl_battery::ChargeStatus),
63 RecoveryEvent,
64 SmeTimeout,
65}
66
67pub async fn setup_cobalt_proxy(
69) -> Result<fidl_fuchsia_metrics::MetricEventLoggerProxy, anyhow::Error> {
70 let cobalt_svc = fuchsia_component::client::connect_to_protocol::<
71 fidl_fuchsia_metrics::MetricEventLoggerFactoryMarker,
72 >()
73 .context("failed to connect to metrics service")?;
74
75 let (cobalt_proxy, cobalt_server) =
76 fidl::endpoints::create_proxy::<fidl_fuchsia_metrics::MetricEventLoggerMarker>();
77
78 let project_spec = fidl_fuchsia_metrics::ProjectSpec {
79 customer_id: Some(metrics::CUSTOMER_ID),
80 project_id: Some(metrics::PROJECT_ID),
81 ..Default::default()
82 };
83
84 match cobalt_svc.create_metric_event_logger(&project_spec, cobalt_server).await {
85 Ok(_) => Ok(cobalt_proxy),
86 Err(err) => Err(format_err!("failed to create metrics event logger: {:?}", err)),
87 }
88}
89
90pub fn setup_disconnected_cobalt_proxy(
93) -> Result<fidl_fuchsia_metrics::MetricEventLoggerProxy, anyhow::Error> {
94 Ok(fidl::endpoints::create_proxy::<fidl_fuchsia_metrics::MetricEventLoggerMarker>().0)
96}
97
98pub fn setup_persistence_req_sender(
99) -> Result<(auto_persist::PersistenceReqSender, impl Future<Output = ()>), anyhow::Error> {
100 fuchsia_component::client::connect_to_protocol::<
101 fidl_fuchsia_diagnostics_persist::DataPersistenceMarker,
102 >()
103 .map(auto_persist::create_persistence_req_sender)
104}
105
106pub fn setup_disconnected_persistence_req_sender() -> auto_persist::PersistenceReqSender {
109 let (sender, _receiver) = mpsc::channel::<String>(1);
110 sender
115}
116
117const TELEMETRY_QUERY_INTERVAL: zx::MonotonicDuration = zx::MonotonicDuration::from_seconds(10);
119
120pub fn serve_telemetry(
121 cobalt_proxy: fidl_fuchsia_metrics::MetricEventLoggerProxy,
122 monitor_svc_proxy: fidl_fuchsia_wlan_device_service::DeviceMonitorProxy,
123 inspect_node: InspectNode,
124 inspect_path: &str,
125 persistence_req_sender: auto_persist::PersistenceReqSender,
126) -> (TelemetrySender, impl Future<Output = Result<(), Error>>) {
127 let (sender, mut receiver) =
128 mpsc::channel::<TelemetryEvent>(util::sender::TELEMETRY_EVENT_BUFFER_SIZE);
129 let sender = TelemetrySender::new(sender);
130
131 const METADATA_NODE_NAME: &str = "metadata";
133 let inspect_metadata_node = inspect_node.create_child(METADATA_NODE_NAME);
134 let inspect_time_series_node = inspect_node.create_child("time_series");
135 let driver_specific_time_series_node = inspect_time_series_node.create_child("driver_specific");
136 let driver_counters_time_series_node =
137 driver_specific_time_series_node.create_child("counters");
138 let driver_gauges_time_series_node = driver_specific_time_series_node.create_child("gauges");
139
140 let (time_matrix_client, time_series_fut) =
141 serve_time_matrix_inspection(inspect_time_series_node);
142 let (driver_counters_time_series_client, driver_counters_time_series_fut) =
143 serve_time_matrix_inspection(driver_counters_time_series_node);
144 let (driver_gauges_time_series_client, driver_gauges_time_series_fut) =
145 serve_time_matrix_inspection(driver_gauges_time_series_node);
146
147 let connect_disconnect = processors::connect_disconnect::ConnectDisconnectLogger::new(
149 cobalt_proxy.clone(),
150 &inspect_node,
151 &inspect_metadata_node,
152 &format!("{inspect_path}/{METADATA_NODE_NAME}"),
153 persistence_req_sender,
154 &time_matrix_client,
155 );
156 let iface_logger = processors::iface::IfaceLogger::new(cobalt_proxy.clone());
157 let power_logger = processors::power::PowerLogger::new(cobalt_proxy.clone(), &inspect_node);
158 let recovery_logger = processors::recovery::RecoveryLogger::new(cobalt_proxy.clone());
159 let mut scan_logger = processors::scan::ScanLogger::new(cobalt_proxy.clone());
160 let sme_timeout_logger = processors::sme_timeout::SmeTimeoutLogger::new(cobalt_proxy.clone());
161 let mut toggle_logger =
162 processors::toggle_events::ToggleLogger::new(cobalt_proxy.clone(), &inspect_node);
163
164 let client_iface_counters_logger =
165 processors::client_iface_counters::ClientIfaceCountersLogger::new(
166 cobalt_proxy,
167 monitor_svc_proxy,
168 &time_matrix_client,
169 driver_counters_time_series_client,
170 driver_gauges_time_series_client,
171 );
172
173 let fut = async move {
174 let _inspect_node = inspect_node;
176 let _inspect_metadata_node = inspect_metadata_node;
177 let _driver_specific_time_series_node = driver_specific_time_series_node;
178
179 let mut telemetry_interval = fasync::Interval::new(TELEMETRY_QUERY_INTERVAL);
180 loop {
181 select! {
182 event = receiver.next() => {
183 let Some(event) = event else {
184 error!("Telemetry event stream unexpectedly terminated.");
185 return Err(format_err!("Telemetry event stream unexpectedly terminated."));
186 };
187 use TelemetryEvent::*;
188 match event {
189 ConnectResult { result, bss } => {
190 connect_disconnect.handle_connect_attempt(result, &bss).await;
191 }
192 Disconnect { info } => {
193 connect_disconnect.log_disconnect(&info).await;
194 power_logger.handle_iface_disconnect(info.iface_id).await;
195 }
196 ClientConnectionsToggle { event } => {
197 toggle_logger.handle_toggle_event(event).await;
198 }
199 ClientIfaceCreated { iface_id } => {
200 client_iface_counters_logger.handle_iface_created(iface_id).await;
201 }
202 ClientIfaceDestroyed { iface_id } => {
203 client_iface_counters_logger.handle_iface_destroyed(iface_id).await;
204 power_logger.handle_iface_destroyed(iface_id).await;
205 }
206 IfaceCreationFailure => {
207 iface_logger.handle_iface_creation_failure().await;
208 }
209 IfaceDestructionFailure => {
210 iface_logger.handle_iface_destruction_failure().await;
211 }
212 ScanStart => {
213 scan_logger.handle_scan_start().await;
214 }
215 ScanResult { result } => {
216 scan_logger.handle_scan_result(result).await;
217 }
218 IfacePowerLevelChanged { iface_power_level, iface_id } => {
219 power_logger.log_iface_power_event(iface_power_level, iface_id).await;
220 }
221 SuspendImminent => {
224 power_logger.handle_suspend_imminent().await;
225 connect_disconnect.handle_suspend_imminent().await;
226 }
227 UnclearPowerDemand(demand) => {
228 power_logger.handle_unclear_power_demand(demand).await;
229 }
230 BatteryChargeStatus(charge_status) => {
231 scan_logger.handle_battery_charge_status(charge_status).await;
232 toggle_logger.handle_battery_charge_status(charge_status).await;
233 }
234 RecoveryEvent => {
235 recovery_logger.handle_recovery_event().await;
236 }
237 SmeTimeout => {
238 sme_timeout_logger.handle_sme_timeout_event().await;
239 }
240 }
241 }
242 _ = telemetry_interval.next() => {
243 connect_disconnect.handle_periodic_telemetry().await;
244 client_iface_counters_logger.handle_periodic_telemetry().await;
245 }
246 }
247 }
248 };
249 let fut = future::try_join4(
250 fut,
251 time_series_fut,
252 driver_counters_time_series_fut,
253 driver_gauges_time_series_fut,
254 )
255 .map_ok(|((), (), (), ())| ());
256 (sender, fut)
257}