診斷與監控

// Inspect properties managed by the server
struct EchoConnectionStats {
    total_requests: fuchsia_inspect::UintProperty,
    bytes_processed: fuchsia_inspect::UintProperty,
}

// Handler for incoming service requests
async fn handle_echo_request(mut stream: EchoRequestStream, stats: &EchoConnectionStats) {
    while let Some(event) = stream.try_next().await.expect("failed to serve echo service") {
        let EchoRequest::EchoString { value, responder } = event;
        responder.send(value.as_ref().map(|s| &**s)).expect("failed to send echo response");

        if let Some(message) = value {
            // Update Inspect property values
            stats.total_requests.add(1);
            stats.bytes_processed.add(message.len() as u64);
        }
    }
}

struct EchoConnectionStats {
  inspect::UintProperty bytes_processed;
  inspect::UintProperty total_requests;
};

// Handler for incoming service requests
class EchoImplementation : public fidl::examples::routing::echo::Echo {
public:
  void EchoString(fidl::StringPtr value, EchoStringCallback callback) override {
    stats_->total_requests.Add(1);
    stats_->bytes_processed.Add(value->size());
    callback(std::move(value));
  }
  fidl::examples::routing::echo::Echo_EventSender* event_sender_;
  std::unique_ptr<EchoConnectionStats> stats_;
};

async fn main() -> Result<(), anyhow::Error> {
    // ...

    // Component is serving and ready to handle incoming requests
    component::health().set_ok();

    // Create request tracking properties 
    let root_node = component::inspector().root(); 
    let stats = EchoConnectionStats { 
        total_requests: root_node.create_uint("total_requests", 0), 
        bytes_processed: root_node.create_uint("bytes_processed", 0), 
    }; 

    // Attach request handler for incoming requests 
    service_fs 
        .for_each_concurrent(None, |request: IncomingRequest| async { 
            match request { 
                IncomingRequest::Echo(stream) => handle_echo_request(stream, &stats).await, 
            } 
        }) 
        .await; 

    Ok(())
}

int main(int argc, const char** argv) {
  // ...

  // Serve the Echo protocol
  EchoImplementation echo_instance;
  fidl::Binding<fidl::examples::routing::echo::Echo> binding(&echo_instance);
  echo_instance.event_sender_ = &binding.events();

  // Create request tracking properties 
  inspect::Node& root_node = inspector.root(); 
  auto total_requests = root_node.CreateUint("total_requests", 0); 
  auto bytes_processed = root_node.CreateUint("bytes_processed", 0); 
  echo_instance.stats_ = std::make_unique<EchoConnectionStats>(EchoConnectionStats{ 
    std::move(bytes_processed), 
    std::move(total_requests), 
  }); 

  fidl::InterfaceRequestHandler<fidl::examples::routing::echo::Echo> handler =
      [&](fidl::InterfaceRequest<fidl::examples::routing::echo::Echo> request) {
        binding.Bind(std::move(request));
      };
  context->outgoing()->AddPublicService(std::move(handler));

  // ...
}

use anyhow::{self, Context};
use fidl_fidl_examples_routing_echo::{EchoRequest, EchoRequestStream};
use fuchsia_component::server::ServiceFs;
use fuchsia_inspect::{component, health::Reporter};
use fuchsia_inspect::NumericProperty;
use futures::prelude::*;

#include <fidl/examples/routing/echo/cpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/fidl/cpp/binding.h>
#include <lib/inspect/cpp/inspect.h>
#include <lib/sys/cpp/component_context.h>
#include <lib/inspect/component/cpp/component.h>