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

fidl_fuchsia_metrics_test/
fidl_fuchsia_metrics_test.rs
