When building a provider, individual probes are added by calling `add_probe` on the `ProviderBuilder` implementation. This method generates that call

A `Provider` is built by calling `define_provider` on a `Tracer` implementation. `define_provider` takes a closure and passes a `ProviderBuilder` para

The implementation of the probing logic is complex enough that it involves the declaration of a few variables and one new struct type. All of this is

Generates the declaration for the "native" C++ functions which fire the probes using whatever the platform's tracing system is. Depending upon the ta

Generates something which indicates if the probe is enabled or not. In some cases it's a static `u16`, in others it's a function that returns a bool.

Generates just the "native" (in the `Disabled` or `NoOp` case it's actually just an empty Rust function) function that fires the probe

Translates what looks to be an explicit call to the associated function corresponding to a probe on a provider trait, into something which at runtime

The provider struct we declare to hold the probe objects needs to take a lot of type parameters. One type, 'a, which corresponds to the lifetime para

Some tracing implementations will use a C++ native function that tests if a probe is enabled or not. Others use a static variable that the Rust code

When we create a new instance of the struct which represents the provider and holds the `ProviderProbe` objects for all of the probes, each of those m

Generates a test-only implementation of UnsafeProviderProbeImpl which passes its parameters to `sprintf` and exposes the resulting string as a Rust st

This doesn't generate ALL test code, but it generates some test helpers that the `probes` module will use.

A provider is described by the user as a `trait`, with methods corresponding to probes. However it's actually implemented as a `struct` with no member

A provider is described by the user as a `trait`, with methods corresponding to probes. However it's actually implemented as a `struct` with no member

For each probe the user defines on the trait, we will generate multiple implementation methods: `(probe_name)` - This is the same name as the method

This generates the declaration of the `UnsafeProviderProbeImpl` trait. This trait implements tracing for implementations that will operate on Rust ty

This generates the declaration of the `UnsafeProviderProbeNativeImpl` trait. This trait provides an implementation of `UnsafeProviderProbeImpl`, whic

Look up the probe by its definition (that is, name and arg types)

The name of the static variable which contains the singleton instance of the provider struct, eg MYPROBESPROVIDERIMPL

The name of the static variable which contains the singleton instance of the underlying tracing system's `Provider` instance, eg MYPROBESPROVIDER

Gets a string containing the Rust type corresponding to the native C type. This also is used for generating code. It corresponds directly to the typ

Converts this error type into a `syn::Error`, preserving context from spans and elements if any were given

Produces an assortment of invalid probe methods, all of which should be rejected by the `from_method` constructor for various reasons

Loads the provider into the process, making the probes available for firing

Translates what looks to be an explicit call to the associated function corresponding to a probe on a provider trait, into something which at runtime

The name of the variable in the implementation struct which will hold this particular probe's `ProviderProbe` wrapper object

Selects a `tracers` implementation given a set of feature flags specified by the user

Actual implementation of the macro logic, factored out of the proc macro itself so that it's more testable

Produces an assortment of valid probe methods, all of which should be accepted by the `from_method` constructor

Re-writes an argument's type information, annotating all references with unique lifetimes Probe function arguments very often will include reference

Convert a Rust string to a CString and then back again. Some of the Quickcheck strings contains NULLs and thus fail this test and convert back as emp