fidl_fuchsia_metrics_test/
fidl_fuchsia_metrics_test.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_metrics_test__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct MetricEventLoggerQuerierMarker;
16
17impl fidl::endpoints::ProtocolMarker for MetricEventLoggerQuerierMarker {
18    type Proxy = MetricEventLoggerQuerierProxy;
19    type RequestStream = MetricEventLoggerQuerierRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = MetricEventLoggerQuerierSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.metrics.test.MetricEventLoggerQuerier";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for MetricEventLoggerQuerierMarker {}
26
27pub trait MetricEventLoggerQuerierProxyInterface: Send + Sync {
28    type WatchLogsResponseFut: std::future::Future<
29            Output = Result<(Vec<fidl_fuchsia_metrics::MetricEvent>, bool), fidl::Error>,
30        > + Send;
31    fn r#watch_logs(&self, project_id: u32, method: LogMethod) -> Self::WatchLogsResponseFut;
32    fn r#reset_logger(&self, project_id: u32, method: LogMethod) -> Result<(), fidl::Error>;
33}
34#[derive(Debug)]
35#[cfg(target_os = "fuchsia")]
36pub struct MetricEventLoggerQuerierSynchronousProxy {
37    client: fidl::client::sync::Client,
38}
39
40#[cfg(target_os = "fuchsia")]
41impl fidl::endpoints::SynchronousProxy for MetricEventLoggerQuerierSynchronousProxy {
42    type Proxy = MetricEventLoggerQuerierProxy;
43    type Protocol = MetricEventLoggerQuerierMarker;
44
45    fn from_channel(inner: fidl::Channel) -> Self {
46        Self::new(inner)
47    }
48
49    fn into_channel(self) -> fidl::Channel {
50        self.client.into_channel()
51    }
52
53    fn as_channel(&self) -> &fidl::Channel {
54        self.client.as_channel()
55    }
56}
57
58#[cfg(target_os = "fuchsia")]
59impl MetricEventLoggerQuerierSynchronousProxy {
60    pub fn new(channel: fidl::Channel) -> Self {
61        let protocol_name =
62            <MetricEventLoggerQuerierMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
63        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
64    }
65
66    pub fn into_channel(self) -> fidl::Channel {
67        self.client.into_channel()
68    }
69
70    /// Waits until an event arrives and returns it. It is safe for other
71    /// threads to make concurrent requests while waiting for an event.
72    pub fn wait_for_event(
73        &self,
74        deadline: zx::MonotonicInstant,
75    ) -> Result<MetricEventLoggerQuerierEvent, fidl::Error> {
76        MetricEventLoggerQuerierEvent::decode(self.client.wait_for_event(deadline)?)
77    }
78
79    /// Returns the _first_ N events that were logged for the logger with the
80    /// given `project_id` and a `more` flag indicating whether there were
81    /// more than N events logged. There is no way to retrieve events logged
82    /// after the first N events.
83    ///
84    /// Will hang until at least one metrics metric is recorded for the given
85    /// `project_id` and `method`.
86    ///
87    /// Repeated calls to WatchLogs for a given LogMethod will block until new
88    /// events are logged with that method, enabling tests to synchronize
89    /// without sleeps or timeouts.
90    pub fn r#watch_logs(
91        &self,
92        mut project_id: u32,
93        mut method: LogMethod,
94        ___deadline: zx::MonotonicInstant,
95    ) -> Result<(Vec<fidl_fuchsia_metrics::MetricEvent>, bool), fidl::Error> {
96        let _response = self.client.send_query::<
97            MetricEventLoggerQuerierWatchLogsRequest,
98            MetricEventLoggerQuerierWatchLogsResponse,
99        >(
100            (project_id, method,),
101            0x42bdf7b98ef8dbea,
102            fidl::encoding::DynamicFlags::empty(),
103            ___deadline,
104        )?;
105        Ok((_response.events, _response.more))
106    }
107
108    /// Clear all logged events by logging `method` for the logger with the
109    /// given `project_id`.
110    ///
111    /// This is a no-op if a logger for the given `project_id` does not exist.
112    /// Notably, it does _not_ create a new logger with `project_id` if one
113    /// does not already exist.
114    pub fn r#reset_logger(
115        &self,
116        mut project_id: u32,
117        mut method: LogMethod,
118    ) -> Result<(), fidl::Error> {
119        self.client.send::<MetricEventLoggerQuerierResetLoggerRequest>(
120            (project_id, method),
121            0x16e0da7907d3190f,
122            fidl::encoding::DynamicFlags::empty(),
123        )
124    }
125}
126
127#[cfg(target_os = "fuchsia")]
128impl From<MetricEventLoggerQuerierSynchronousProxy> for zx::Handle {
129    fn from(value: MetricEventLoggerQuerierSynchronousProxy) -> Self {
130        value.into_channel().into()
131    }
132}
133
134#[cfg(target_os = "fuchsia")]
135impl From<fidl::Channel> for MetricEventLoggerQuerierSynchronousProxy {
136    fn from(value: fidl::Channel) -> Self {
137        Self::new(value)
138    }
139}
140
141#[cfg(target_os = "fuchsia")]
142impl fidl::endpoints::FromClient for MetricEventLoggerQuerierSynchronousProxy {
143    type Protocol = MetricEventLoggerQuerierMarker;
144
145    fn from_client(value: fidl::endpoints::ClientEnd<MetricEventLoggerQuerierMarker>) -> Self {
146        Self::new(value.into_channel())
147    }
148}
149
150#[derive(Debug, Clone)]
151pub struct MetricEventLoggerQuerierProxy {
152    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
153}
154
155impl fidl::endpoints::Proxy for MetricEventLoggerQuerierProxy {
156    type Protocol = MetricEventLoggerQuerierMarker;
157
158    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
159        Self::new(inner)
160    }
161
162    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
163        self.client.into_channel().map_err(|client| Self { client })
164    }
165
166    fn as_channel(&self) -> &::fidl::AsyncChannel {
167        self.client.as_channel()
168    }
169}
170
171impl MetricEventLoggerQuerierProxy {
172    /// Create a new Proxy for fuchsia.metrics.test/MetricEventLoggerQuerier.
173    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
174        let protocol_name =
175            <MetricEventLoggerQuerierMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
176        Self { client: fidl::client::Client::new(channel, protocol_name) }
177    }
178
179    /// Get a Stream of events from the remote end of the protocol.
180    ///
181    /// # Panics
182    ///
183    /// Panics if the event stream was already taken.
184    pub fn take_event_stream(&self) -> MetricEventLoggerQuerierEventStream {
185        MetricEventLoggerQuerierEventStream { event_receiver: self.client.take_event_receiver() }
186    }
187
188    /// Returns the _first_ N events that were logged for the logger with the
189    /// given `project_id` and a `more` flag indicating whether there were
190    /// more than N events logged. There is no way to retrieve events logged
191    /// after the first N events.
192    ///
193    /// Will hang until at least one metrics metric is recorded for the given
194    /// `project_id` and `method`.
195    ///
196    /// Repeated calls to WatchLogs for a given LogMethod will block until new
197    /// events are logged with that method, enabling tests to synchronize
198    /// without sleeps or timeouts.
199    pub fn r#watch_logs(
200        &self,
201        mut project_id: u32,
202        mut method: LogMethod,
203    ) -> fidl::client::QueryResponseFut<
204        (Vec<fidl_fuchsia_metrics::MetricEvent>, bool),
205        fidl::encoding::DefaultFuchsiaResourceDialect,
206    > {
207        MetricEventLoggerQuerierProxyInterface::r#watch_logs(self, project_id, method)
208    }
209
210    /// Clear all logged events by logging `method` for the logger with the
211    /// given `project_id`.
212    ///
213    /// This is a no-op if a logger for the given `project_id` does not exist.
214    /// Notably, it does _not_ create a new logger with `project_id` if one
215    /// does not already exist.
216    pub fn r#reset_logger(
217        &self,
218        mut project_id: u32,
219        mut method: LogMethod,
220    ) -> Result<(), fidl::Error> {
221        MetricEventLoggerQuerierProxyInterface::r#reset_logger(self, project_id, method)
222    }
223}
224
225impl MetricEventLoggerQuerierProxyInterface for MetricEventLoggerQuerierProxy {
226    type WatchLogsResponseFut = fidl::client::QueryResponseFut<
227        (Vec<fidl_fuchsia_metrics::MetricEvent>, bool),
228        fidl::encoding::DefaultFuchsiaResourceDialect,
229    >;
230    fn r#watch_logs(
231        &self,
232        mut project_id: u32,
233        mut method: LogMethod,
234    ) -> Self::WatchLogsResponseFut {
235        fn _decode(
236            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
237        ) -> Result<(Vec<fidl_fuchsia_metrics::MetricEvent>, bool), fidl::Error> {
238            let _response = fidl::client::decode_transaction_body::<
239                MetricEventLoggerQuerierWatchLogsResponse,
240                fidl::encoding::DefaultFuchsiaResourceDialect,
241                0x42bdf7b98ef8dbea,
242            >(_buf?)?;
243            Ok((_response.events, _response.more))
244        }
245        self.client.send_query_and_decode::<
246            MetricEventLoggerQuerierWatchLogsRequest,
247            (Vec<fidl_fuchsia_metrics::MetricEvent>, bool),
248        >(
249            (project_id, method,),
250            0x42bdf7b98ef8dbea,
251            fidl::encoding::DynamicFlags::empty(),
252            _decode,
253        )
254    }
255
256    fn r#reset_logger(
257        &self,
258        mut project_id: u32,
259        mut method: LogMethod,
260    ) -> Result<(), fidl::Error> {
261        self.client.send::<MetricEventLoggerQuerierResetLoggerRequest>(
262            (project_id, method),
263            0x16e0da7907d3190f,
264            fidl::encoding::DynamicFlags::empty(),
265        )
266    }
267}
268
269pub struct MetricEventLoggerQuerierEventStream {
270    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
271}
272
273impl std::marker::Unpin for MetricEventLoggerQuerierEventStream {}
274
275impl futures::stream::FusedStream for MetricEventLoggerQuerierEventStream {
276    fn is_terminated(&self) -> bool {
277        self.event_receiver.is_terminated()
278    }
279}
280
281impl futures::Stream for MetricEventLoggerQuerierEventStream {
282    type Item = Result<MetricEventLoggerQuerierEvent, fidl::Error>;
283
284    fn poll_next(
285        mut self: std::pin::Pin<&mut Self>,
286        cx: &mut std::task::Context<'_>,
287    ) -> std::task::Poll<Option<Self::Item>> {
288        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
289            &mut self.event_receiver,
290            cx
291        )?) {
292            Some(buf) => std::task::Poll::Ready(Some(MetricEventLoggerQuerierEvent::decode(buf))),
293            None => std::task::Poll::Ready(None),
294        }
295    }
296}
297
298#[derive(Debug)]
299pub enum MetricEventLoggerQuerierEvent {}
300
301impl MetricEventLoggerQuerierEvent {
302    /// Decodes a message buffer as a [`MetricEventLoggerQuerierEvent`].
303    fn decode(
304        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
305    ) -> Result<MetricEventLoggerQuerierEvent, fidl::Error> {
306        let (bytes, _handles) = buf.split_mut();
307        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
308        debug_assert_eq!(tx_header.tx_id, 0);
309        match tx_header.ordinal {
310            _ => Err(fidl::Error::UnknownOrdinal {
311                ordinal: tx_header.ordinal,
312                protocol_name:
313                    <MetricEventLoggerQuerierMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
314            }),
315        }
316    }
317}
318
319/// A Stream of incoming requests for fuchsia.metrics.test/MetricEventLoggerQuerier.
320pub struct MetricEventLoggerQuerierRequestStream {
321    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
322    is_terminated: bool,
323}
324
325impl std::marker::Unpin for MetricEventLoggerQuerierRequestStream {}
326
327impl futures::stream::FusedStream for MetricEventLoggerQuerierRequestStream {
328    fn is_terminated(&self) -> bool {
329        self.is_terminated
330    }
331}
332
333impl fidl::endpoints::RequestStream for MetricEventLoggerQuerierRequestStream {
334    type Protocol = MetricEventLoggerQuerierMarker;
335    type ControlHandle = MetricEventLoggerQuerierControlHandle;
336
337    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
338        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
339    }
340
341    fn control_handle(&self) -> Self::ControlHandle {
342        MetricEventLoggerQuerierControlHandle { inner: self.inner.clone() }
343    }
344
345    fn into_inner(
346        self,
347    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
348    {
349        (self.inner, self.is_terminated)
350    }
351
352    fn from_inner(
353        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
354        is_terminated: bool,
355    ) -> Self {
356        Self { inner, is_terminated }
357    }
358}
359
360impl futures::Stream for MetricEventLoggerQuerierRequestStream {
361    type Item = Result<MetricEventLoggerQuerierRequest, fidl::Error>;
362
363    fn poll_next(
364        mut self: std::pin::Pin<&mut Self>,
365        cx: &mut std::task::Context<'_>,
366    ) -> std::task::Poll<Option<Self::Item>> {
367        let this = &mut *self;
368        if this.inner.check_shutdown(cx) {
369            this.is_terminated = true;
370            return std::task::Poll::Ready(None);
371        }
372        if this.is_terminated {
373            panic!("polled MetricEventLoggerQuerierRequestStream after completion");
374        }
375        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
376            |bytes, handles| {
377                match this.inner.channel().read_etc(cx, bytes, handles) {
378                    std::task::Poll::Ready(Ok(())) => {}
379                    std::task::Poll::Pending => return std::task::Poll::Pending,
380                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
381                        this.is_terminated = true;
382                        return std::task::Poll::Ready(None);
383                    }
384                    std::task::Poll::Ready(Err(e)) => {
385                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
386                            e.into(),
387                        ))))
388                    }
389                }
390
391                // A message has been received from the channel
392                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
393
394                std::task::Poll::Ready(Some(match header.ordinal {
395                0x42bdf7b98ef8dbea => {
396                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
397                    let mut req = fidl::new_empty!(MetricEventLoggerQuerierWatchLogsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
398                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MetricEventLoggerQuerierWatchLogsRequest>(&header, _body_bytes, handles, &mut req)?;
399                    let control_handle = MetricEventLoggerQuerierControlHandle {
400                        inner: this.inner.clone(),
401                    };
402                    Ok(MetricEventLoggerQuerierRequest::WatchLogs {project_id: req.project_id,
403method: req.method,
404
405                        responder: MetricEventLoggerQuerierWatchLogsResponder {
406                            control_handle: std::mem::ManuallyDrop::new(control_handle),
407                            tx_id: header.tx_id,
408                        },
409                    })
410                }
411                0x16e0da7907d3190f => {
412                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
413                    let mut req = fidl::new_empty!(MetricEventLoggerQuerierResetLoggerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
414                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MetricEventLoggerQuerierResetLoggerRequest>(&header, _body_bytes, handles, &mut req)?;
415                    let control_handle = MetricEventLoggerQuerierControlHandle {
416                        inner: this.inner.clone(),
417                    };
418                    Ok(MetricEventLoggerQuerierRequest::ResetLogger {project_id: req.project_id,
419method: req.method,
420
421                        control_handle,
422                    })
423                }
424                _ => Err(fidl::Error::UnknownOrdinal {
425                    ordinal: header.ordinal,
426                    protocol_name: <MetricEventLoggerQuerierMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
427                }),
428            }))
429            },
430        )
431    }
432}
433
434/// LoggerQuerier provides a way to query mock metrics services to check that
435/// clients of metrics are logging events as expected.
436#[derive(Debug)]
437pub enum MetricEventLoggerQuerierRequest {
438    /// Returns the _first_ N events that were logged for the logger with the
439    /// given `project_id` and a `more` flag indicating whether there were
440    /// more than N events logged. There is no way to retrieve events logged
441    /// after the first N events.
442    ///
443    /// Will hang until at least one metrics metric is recorded for the given
444    /// `project_id` and `method`.
445    ///
446    /// Repeated calls to WatchLogs for a given LogMethod will block until new
447    /// events are logged with that method, enabling tests to synchronize
448    /// without sleeps or timeouts.
449    WatchLogs {
450        project_id: u32,
451        method: LogMethod,
452        responder: MetricEventLoggerQuerierWatchLogsResponder,
453    },
454    /// Clear all logged events by logging `method` for the logger with the
455    /// given `project_id`.
456    ///
457    /// This is a no-op if a logger for the given `project_id` does not exist.
458    /// Notably, it does _not_ create a new logger with `project_id` if one
459    /// does not already exist.
460    ResetLogger {
461        project_id: u32,
462        method: LogMethod,
463        control_handle: MetricEventLoggerQuerierControlHandle,
464    },
465}
466
467impl MetricEventLoggerQuerierRequest {
468    #[allow(irrefutable_let_patterns)]
469    pub fn into_watch_logs(
470        self,
471    ) -> Option<(u32, LogMethod, MetricEventLoggerQuerierWatchLogsResponder)> {
472        if let MetricEventLoggerQuerierRequest::WatchLogs { project_id, method, responder } = self {
473            Some((project_id, method, responder))
474        } else {
475            None
476        }
477    }
478
479    #[allow(irrefutable_let_patterns)]
480    pub fn into_reset_logger(
481        self,
482    ) -> Option<(u32, LogMethod, MetricEventLoggerQuerierControlHandle)> {
483        if let MetricEventLoggerQuerierRequest::ResetLogger { project_id, method, control_handle } =
484            self
485        {
486            Some((project_id, method, control_handle))
487        } else {
488            None
489        }
490    }
491
492    /// Name of the method defined in FIDL
493    pub fn method_name(&self) -> &'static str {
494        match *self {
495            MetricEventLoggerQuerierRequest::WatchLogs { .. } => "watch_logs",
496            MetricEventLoggerQuerierRequest::ResetLogger { .. } => "reset_logger",
497        }
498    }
499}
500
501#[derive(Debug, Clone)]
502pub struct MetricEventLoggerQuerierControlHandle {
503    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
504}
505
506impl fidl::endpoints::ControlHandle for MetricEventLoggerQuerierControlHandle {
507    fn shutdown(&self) {
508        self.inner.shutdown()
509    }
510    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
511        self.inner.shutdown_with_epitaph(status)
512    }
513
514    fn is_closed(&self) -> bool {
515        self.inner.channel().is_closed()
516    }
517    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
518        self.inner.channel().on_closed()
519    }
520
521    #[cfg(target_os = "fuchsia")]
522    fn signal_peer(
523        &self,
524        clear_mask: zx::Signals,
525        set_mask: zx::Signals,
526    ) -> Result<(), zx_status::Status> {
527        use fidl::Peered;
528        self.inner.channel().signal_peer(clear_mask, set_mask)
529    }
530}
531
532impl MetricEventLoggerQuerierControlHandle {}
533
534#[must_use = "FIDL methods require a response to be sent"]
535#[derive(Debug)]
536pub struct MetricEventLoggerQuerierWatchLogsResponder {
537    control_handle: std::mem::ManuallyDrop<MetricEventLoggerQuerierControlHandle>,
538    tx_id: u32,
539}
540
541/// Set the the channel to be shutdown (see [`MetricEventLoggerQuerierControlHandle::shutdown`])
542/// if the responder is dropped without sending a response, so that the client
543/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
544impl std::ops::Drop for MetricEventLoggerQuerierWatchLogsResponder {
545    fn drop(&mut self) {
546        self.control_handle.shutdown();
547        // Safety: drops once, never accessed again
548        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
549    }
550}
551
552impl fidl::endpoints::Responder for MetricEventLoggerQuerierWatchLogsResponder {
553    type ControlHandle = MetricEventLoggerQuerierControlHandle;
554
555    fn control_handle(&self) -> &MetricEventLoggerQuerierControlHandle {
556        &self.control_handle
557    }
558
559    fn drop_without_shutdown(mut self) {
560        // Safety: drops once, never accessed again due to mem::forget
561        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
562        // Prevent Drop from running (which would shut down the channel)
563        std::mem::forget(self);
564    }
565}
566
567impl MetricEventLoggerQuerierWatchLogsResponder {
568    /// Sends a response to the FIDL transaction.
569    ///
570    /// Sets the channel to shutdown if an error occurs.
571    pub fn send(
572        self,
573        mut events: &[fidl_fuchsia_metrics::MetricEvent],
574        mut more: bool,
575    ) -> Result<(), fidl::Error> {
576        let _result = self.send_raw(events, more);
577        if _result.is_err() {
578            self.control_handle.shutdown();
579        }
580        self.drop_without_shutdown();
581        _result
582    }
583
584    /// Similar to "send" but does not shutdown the channel if an error occurs.
585    pub fn send_no_shutdown_on_err(
586        self,
587        mut events: &[fidl_fuchsia_metrics::MetricEvent],
588        mut more: bool,
589    ) -> Result<(), fidl::Error> {
590        let _result = self.send_raw(events, more);
591        self.drop_without_shutdown();
592        _result
593    }
594
595    fn send_raw(
596        &self,
597        mut events: &[fidl_fuchsia_metrics::MetricEvent],
598        mut more: bool,
599    ) -> Result<(), fidl::Error> {
600        self.control_handle.inner.send::<MetricEventLoggerQuerierWatchLogsResponse>(
601            (events, more),
602            self.tx_id,
603            0x42bdf7b98ef8dbea,
604            fidl::encoding::DynamicFlags::empty(),
605        )
606    }
607}
608
609mod internal {
610    use super::*;
611}
fidl_fuchsia_metrics_test/fidl_fuchsia_metrics_test.rs

fidl_fuchsia_metrics_test/
fidl_fuchsia_metrics_test.rs
