Registering a trace provider

Trace providers must register with the trace manager in order to participate in tracing. Drivers don't have to register as a trace provider since the devhost process does it through libdriver.so.

To register a trace provider, you must do the following:

• Register with the trace manager
• Give the trace manager component access

Register with the trace manager

To register as a trace provider, you can use the libtrace-provider library to provide an asynchronous loop in your component's code.

For example:

#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/trace-provider/provider.h>
// further includes

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

  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);
  trace::TraceProviderWithFdio trace_provider(
      loop.dispatcher(), "my_trace_provider");

  // further setup

  loop.Run();
  return 0;
}

#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/trace-provider/provider.h>

int main(int argc, char** argv) {
  zx_status_t status;
  async_loop_t* loop;
  trace_provider_t* trace_provider;

  // Create a message loop.
  status = async_loop_create(&kAsyncLoopConfigNoAttachToCurrentThread, &loop);
  if (status != ZX_OK) exit(1);

  // Start a thread for the loop to run on.
  // Alternatively, use async_loop_run() to run on the current thread.
  status = async_loop_start_thread(loop, "loop", NULL);
  if (status != ZX_OK) exit(1);

  // Create the trace provider.
  async_dispatcher_t* dispatcher = async_loop_get_dispatcher(loop);
  trace_provider = trace_provider_create(dispatcher);
  if (!trace_provider) exit(1);

  // Do something...

  // Tear down.
  trace_provider_destroy(trace_provider);
  async_loop_shutdown(loop);
  return 0;
}

fn main() {
    fuchsia_trace_provider::trace_provider_create_with_fdio();
    // ...
}

Give the trace manager component access

In the component manifest file (a .cml file) of your component, you must specify that it needs to communicate with the Fuchsia trace manager.

To give the trace manager component access, specify the protocol fuchsia.tracing.provider.Registry as a use declaration. For example:

{
    program: {
        runner: "elf",
        binary: "bin/app",
    },
    use: [
        {
            protocol: [
                "fuchsia.tracing.provider.Registry",
            ],
        },
    ],
}

If your component is in core, you should route the capability from trace_manager to your component directly in core.cml. Otherwise, you should do so in your component's core_shard.cml.

// component.core_shard.cml
{
offer: [
      {
          protocol: "fuchsia.tracing.provider.Registry",
          from: "#trace_manager",
          to: "#your_component",

          // Allows manifest validation to succeed if tracing is not compiled
          // into the product
          source_availability: "unknown",
      },
]
}

If your component uses a Chromium-based fuchsia.web service and you would like to be able to collect trace data from it, ensure that your Context is provided both the fuchsia.tracing.provider.Registry and fuchsia.tracing.perfetto.ProducerConnector capabilities.

Once you have registered your component as a trace provider, you can enable tracing in your code. For more information, see Adding tracing in your code.