System.Diagnostics.DiagnosticSource

This is the basic API to 'hook' parts of the framework. It is like an EventSource (which can also write object), but is intended to log complex objects that can't be serialized. Please See the DiagnosticSource Users Guide https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/DiagnosticSourceUsersGuide.md for instructions on its use.

Write is a generic way of logging complex payloads. Each notification is given a name, which identifies it as well as a object (typically an anonymous type) that gives the information to pass to the notification, which is arbitrary. The name should be short (so don't use fully qualified names unless you have to to avoid ambiguity), but you want the name to be globally unique. Typically your componentName.eventName where componentName and eventName are strings less than 10 characters are a good compromise. notification names should NOT have '.' in them because component names have dots and for them both to have dots would lead to ambiguity. The suggestion is to use _ instead. It is assumed that listeners will use string prefixing to filter groups, thus having hierarchy in component names is good.

The name of the event being written. An object that represent the value being passed as a payload for the event. This is often an anonymous type which contains several sub-values.

Optional: if there is expensive setup for the notification, you can call IsEnabled before doing this setup. Consumers should not be assuming that they only get notifications for which IsEnabled is true however, it is optional for producers to call this API. The name should be the same as what is passed to Write.

The name of the event being written.

Optional: if there is expensive setup for the notification, you can call IsEnabled before doing this setup with context

The name of the event being written. An object that represents the additional context for IsEnabled. Consumers should expect to receive null which may indicate that producer called pure IsEnabled(string) to check if consumer wants to get notifications for such events at all. Based on it, producer may call IsEnabled(string, object, object) again with non-null context Optional. An object that represents the additional context for IsEnabled. Null by default. Consumers should expect to receive null which may indicate that producer called pure IsEnabled(string) or producer passed all necessary context in arg1

Starts an Activity and writes start event. Activity describes logical operation, its context and parent relation; Current activity flows through the operation processing. This method starts given Activity (maintains global Current Activity and Parent for the given activity) and notifies consumers that new Activity was started. Consumers could access to add context and/or augment telemetry. Producers may pass additional details to the consumer in the payload.

Activity to be started An object that represent the value being passed as a payload for the event. Started Activity for convenient chaining

Stops given Activity: maintains global Current Activity and notifies consumers that Activity was stopped. Consumers could access to add context and/or augment telemetry. Producers may pass additional details to the consumer in the payload.

Activity to be stopped An object that represent the value being passed as a payload for the event.

Optional: If an instrumentation site creating an new activity that was caused by something outside the process (e.g. an incomming HTTP request), then that site will want to make a new activity and transfer state from that incoming request to the activity. To the extent possible this should be done by the instrumentation site (because it is a contract between Activity and the incomming request logic at the instrumentation site. However the instrumentation site can't handle policy (for example if sampling is done exactly which requests should be sampled) For this the instrumentation site needs to call back out to the logging system and ask it to resolve policy (e.g. decide if the Activity's 'sampling' bit should be set) This is what OnActivityImport is for. It is given the activity as well as a payload object that represents the incomming request. The DiagnosticSource's subscribers then have the opportunity to update this activity as desired. Note that this callout is rarely used at instrumentation sites (only those sites that are on the 'boundry' of the process), and the instrumentation site will implement some default policy (it sets the activity in SOME way), and so this method does not need to be overriden if that default policy is fine. Thus this is call should be used rare (but often important) cases. Note that the type of 'payload' is typed as object here, but for any particular instrumentation site and the subscriber will know the type of the payload and thus cast it and decode it if it needs to.

Optional: If an instrumentation site is at a location where activities leave the process (e.g. an outgoing HTTP request), then that site will want to transfer state from the activity to the outgoing request. To the extent possible this should be done by the instrumentation site (because it is a contract between Activity and the outgoing request logic at the instrumentation site. However the instrumentation site can't handle policy (for example whether activity information should be disabled, or written in a older format for compatibility reasons). For this the instrumentation site needs to call back out to the logging system and ask it to resolve policy. This is what OnActivityExport is for. It is given the activity as well as a payloay object that represents the outgoing request. The DiagnosticSource's subscriber then have the ability to update the outgoing request before it is sent. Note that this callout is rarely used at instrumentation sites (only those sites that are on an outgoing 'boundry' of the process). Moreover typically the default policy that the instrumentation site performs (transfer all activity state in a particular outgoing convention), is likely to be fine. This is only for cases where that is a problem. Thus this is call should be used very rarely and is mostly here for symetry with OnActivityImport and future-proofing. Note that the type of 'payload' is typed as object here, but for any particular instrumentation site and the subscriber should know the type of the payload and thus cast it and decode it if it needs to.

A DiagnosticListener is something that forwards on events written with DiagnosticSource. It is an IObservable (has Subscribe method), and it also has a Subscribe overloads that lets you specify a 'IsEnabled' predicate that users of DiagnosticSource will use for 'quick checks'. The item in the stream is a KeyValuePair[string, object] where the string is the name of the diagnostic item and the object is the payload (typically an anonymous type). There may be many DiagnosticListeners in the system, but we encourage the use of The DiagnosticSource.DefaultSource which goes to the DiagnosticListener.DefaultListener. If you need to see 'everything' you can subscribe to the 'AllListeners' event that will fire for every live DiagnosticListener in the appdomain (past or present). Please See the DiagnosticSource Users Guide https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/DiagnosticSourceUsersGuide.md for instructions on its use.

When you subscribe to this you get callbacks for all NotificationListeners in the appdomain as well as those that occurred in the past, and all future Listeners created in the future.

Add a subscriber (Observer). If the isEnabled parameter is non-null it indicates that some events are uninteresting and can be skipped for efficiency.

Subscriber (IObserver) Filters events based on their name (string). Should return true if the event is enabled. Note that the isEnabled predicate is an OPTIONAL OPTIMIZATION to allow the instrumentation site to avoid setting up the payload and calling 'Write' when no subscriber cares about it. In particular the instrumentation site has the option of ignoring the IsEnabled() predicate (not calling it) and simply calling Write(). Thus if the subscriber requires the filtering, it needs to do it itself. If this parameter is null, no filtering is done (all overloads of DiagnosticSource.IsEnabled return true).

Add a subscriber (Observer). If the isEnabled parameter is non-null indicates that some events are uninteresting can be skipped for efficiency.

Subscriber (IObserver) Filters events based on their name (string) and up to two context object (which can be null). A particular instrumentation site HAS THE OPTION of calling one or more 'IsEnabled' overloads in which it passes the name of the event and up to two other (instrumentation site specific) objects as arguments. If any of these 'IsEnabled' calls are made then this 'isEnabled' predicate is invoked with passed values (if shorter overloads are used, null is passed for missing context objects). This gives any particular instrumentation site the ability to pass up to two pieces of information to the subscriber to do sophisticated, efficient filtering. This requires more coupling between the instrumentation site and the subscriber code. It IS expected that a particular instrumentation site may call different overloads of IsEnabled for the same event, first calling IsEnable(string) which calls the filter with two null context objects and if 'isEnabled' returns true calling again with context objects. The isEnabled filter should be designed with this in mind. Note that the isEnabled predicate is an OPTIONAL OPTIMIZATION to allow the instrumentation site to avoid setting up the payload and calling 'Write' when no subscriber cares about it. In particular the instrumentation site has the option of ignoring the IsEnabled() predicate (not calling it) and simply calling Write(). Thus if the subscriber requires the filtering, it needs to do it itself. If this parameter is null, no filtering is done (all overloads of DiagnosticSource.IsEnabled return true).

Same as other Subscribe overload where the predicate is assumed to always return true.

Make a new DiagnosticListener, it is a NotificationSource, which means the returned result can be used to log notifications, but it also has a Subscribe method so notifications can be forwarded arbitrarily. Thus its job is to forward things from the producer to all the listeners (multi-casting). Generally you should not be making your own DiagnosticListener but use the DiagnosticListener.Default, so that notifications are as 'public' as possible.

Clean up the NotificationListeners. Notification listeners do NOT DIE ON THEIR OWN because they are in a global list (for discoverability). You must dispose them explicitly. Note that we do not do the Dispose(bool) pattern because we frankly don't want to support subclasses that have non-managed state.

When a DiagnosticListener is created it is given a name. Return this.

Return the name for the ToString() to aid in debugging.

Determines whether there are any registered subscribers

If there is an expensive setup for the notification, you may call IsEnabled() as the first and most efficient check before doing this setup. Producers may optionally use this check before IsEnabled(string) in the most performance-critical parts of the system to ensure somebody listens to the DiagnosticListener at all.

Override abstract method

Logically AllListenerObservable has a very simple task. It has a linked list of subscribers that want a callback when a new listener gets created. When a new DiagnosticListener gets created it should call OnNewDiagnosticListener so that AllListenerObservable can forward it on to all the subscribers.

Called when a new DiagnosticListener gets created to tell anyone who subscribed that this happened.

Remove 'subscription from the list of subscriptions that the observable has. Called when subscriptions are disposed. Returns true if the subscription was removed.

One node in the linked list of subscriptions that AllListenerObservable keeps. It is IDisposable, and when that is called it removes itself from the list.

Add a subscriber (Observer). If the isEnabled parameter is non-null indicates that some events are uninteresting can be skipped for efficiency. You can also supply an 'onActivityImport' and 'onActivityExport' methods that should be called when providers are 'importing' or 'exporting' activities from outside the process (e.g. from Http Requests). These are called right after importing (exporting) the activity and can be used to modify the activity (or outgoing request) to add policy.

DiagnosticSourceEventSource serves two purposes 1) It allows debuggers to inject code via Function evaluation. This is the purpose of the BreakPointWithDebuggerFuncEval function in the 'OnEventCommand' method. Basically even in release code, debuggers can place a breakpoint in this method and then trigger the DiagnosticSourceEventSource via ETW. Thus from outside the process you can get a hook that is guaranteed to happen BEFORE any DiagnosticSource events (if the process is just starting) or as soon as possible afterward if it is on attach. 2) It provides a 'bridge' that allows DiagnosticSource messages to be forwarded to EventListers or ETW. You can do this by enabling the Microsoft-Diagnostics-DiagnosticSource with the 'Events' keyword (for diagnostics purposes, you should also turn on the 'Messages' keyword. This EventSource defines a EventSource argument called 'FilterAndPayloadSpecs' that defines what DiagnosticSources to enable and what parts of the payload to serialize into the key-value list that will be forwarded to the EventSource. If it is empty, values of properties of the diagnostic source payload are dumped as strings (using ToString()) and forwarded to the EventSource. For what people think of as serializable object strings, primitives this gives you want you want. (the value of the property in string form) for what people think of as non-serializable objects (e.g. HttpContext) the ToString() method is typically not defined, so you get the Object.ToString() implementation that prints the type name. This is useful since this is the information you need (the type of the property) to discover the field names so you can create a transform specification that will pick off the properties you desire. Once you have the particular values you desire, the implicit payload elements are typically not needed anymore and you can prefix the Transform specification with a '-' which suppresses the implicit transform (you only get the values of the properties you specifically ask for. Logically a transform specification is simply a fetching specification X.Y.Z along with a name to give it in the output (which defaults to the last name in the fetch specification). The FilterAndPayloadSpecs is one long string with the following structures * It is a newline separated list of FILTER_AND_PAYLOAD_SPEC * a FILTER_AND_PAYLOAD_SPEC can be * EVENT_NAME : TRANSFORM_SPECS * EMPTY - turns on all sources with implicit payload elements. * an EVENTNAME can be * DIAGNOSTIC_SOURCE_NAME / DIAGNOSTIC_EVENT_NAME @ EVENT_SOURCE_EVENTNAME - give the name as well as the EventSource event to log it under. * DIAGNOSTIC_SOURCE_NAME / DIAGNOSTIC_EVENT_NAME * DIAGNOSTIC_SOURCE_NAME - which wildcards every event in the Diagnostic source or * EMPTY - which turns on all sources Or it can be "[AS] ACTIVITY_SOURCE_NAME + ACTIVITY_NAME / ACTIVITY_EVENT_NAME - SAMPLING_RESULT" * All parts are optional and can be empty string. * ACTIVITY_SOURCE_NAME can be "*" to listen to all ActivitySources * ACTIVITY_SOURCE_NAME can be empty string which will listen to ActivitySource that create Activities using "new Activity(...)" * ACTIVITY_NAME is the activity operation name to filter with. * ACTIVITY_EVENT_NAME either "Start" to listen to Activity Start event, or "Stop" to listen to Activity Stop event, or empty string to listen to both Start and Stop Activity events. * SAMPLING_RESULT either "Propagate" to create the Activity with PropagationData, or "Record" to create the Activity with AllData, or empty string to create the Activity with AllDataAndRecorded * TRANSFORM_SPEC is a semicolon separated list of TRANSFORM_SPEC, which can be * - TRANSFORM_SPEC - the '-' indicates that implicit payload elements should be suppressed * VARIABLE_NAME = PROPERTY_SPEC - indicates that a payload element 'VARIABLE_NAME' is created from PROPERTY_SPEC * PROPERTY_SPEC - This is a shortcut where VARIABLE_NAME is the LAST property name * a PROPERTY_SPEC is basically a list of names separated by '.' * PROPERTY_NAME - fetches a property from the DiagnosticSource payload object * PROPERTY_NAME . PROPERTY NAME - fetches a sub-property of the object. * *Activity - fetches Activity.Current * *Enumerate - enumerates all the items in an IEnumerable, calls ToString() on them, and joins the strings in a comma separated list. Example1: "BridgeTestSource1/TestEvent1:cls_Point_X=cls.Point.X;cls_Point_Y=cls.Point.Y\r\n" + "BridgeTestSource2/TestEvent2:-cls.Url" This indicates that two events should be turned on, The 'TestEvent1' event in BridgeTestSource1 and the 'TestEvent2' in BridgeTestSource2. In the first case, because the transform did not begin with a - any primitive type/string of 'TestEvent1's payload will be serialized into the output. In addition if there a property of the payload object called 'cls' which in turn has a property 'Point' which in turn has a property 'X' then that data is also put in the output with the name cls_Point_X. Similarly if cls.Point.Y exists, then that value will also be put in the output with the name cls_Point_Y. For the 'BridgeTestSource2/TestEvent2' event, because the - was specified NO implicit fields will be generated, but if there is a property call 'cls' which has a property 'Url' then that will be placed in the output with the name 'Url' (since that was the last property name used and no Variable= clause was specified. Example: "BridgeTestSource1\r\n" + "BridgeTestSource2" This will enable all events for the BridgeTestSource1 and BridgeTestSource2 sources. Any string/primitive properties of any of the events will be serialized into the output. Example: "" This turns on all DiagnosticSources Any string/primitive properties of any of the events will be serialized into the output. This is not likely to be a good idea as it will be very verbose, but is useful to quickly discover what is available. Example: "[AS]*" listen to all ActivitySources and all Activities events (Start/Stop). Activities will be created with AllDataAndRecorded sampling. "[AS]" listen to default ActivitySource and Activities events (Start/Stop) while the Activity is created using "new Activity(...)". Such Activities will be created with AllDataAndRecorded sampling. "[AS]MyLibrary/Start" listen to `MyLibrary` ActivitySource and the 'Start' Activity event. The Activities will be created with AllDataAndRecorded sampling. "[AS]MyLibrary/-Propagate" listen to `MyLibrary` ActivitySource and the 'Start and Stop' Activity events. The Activities will be created with PropagationData sampling. "[AS]MyLibrary/Stop-Record" listen to `MyLibrary` ActivitySource and the 'Stop' Activity event. The Activities will be created with AllData sampling. "[AS]*/-" listen to all ActivitySources and the Start and Stop Activity events. Activities will be created with AllDataAndRecorded sampling. this equivalent to "[AS]*" too. "[AS]*+MyActivity" listen to all activity sources when creating Activity with the operation name "MyActivity". * How data is logged in the EventSource By default all data from DiagnosticSources is logged to the DiagnosticEventSource event called 'Event' which has three fields string SourceName, string EventName, IEnumerable[KeyValuePair[string, string]] Argument However to support start-stop activity tracking, there are six other events that can be used Activity1Start Activity1Stop Activity2Start Activity2Stop RecursiveActivity1Start RecursiveActivity1Stop By using the SourceName/EventName@EventSourceName syntax, you can force particular DiagnosticSource events to be logged with one of these EventSource events. This is useful because the events above have start-stop semantics which means that they create activity IDs that are attached to all logging messages between the start and the stop (see https://blogs.msdn.microsoft.com/vancem/2015/09/14/exploring-eventsource-activity-correlation-and-causation-features/) For example the specification "MyDiagnosticSource/RequestStart@Activity1Start\r\n" + "MyDiagnosticSource/RequestStop@Activity1Stop\r\n" + "MyDiagnosticSource/SecurityStart@Activity2Start\r\n" + "MyDiagnosticSource/SecurityStop@Activity2Stop\r\n" Defines that RequestStart will be logged with the EventSource Event Activity1Start (and the corresponding stop) which means that all events caused between these two markers will have an activity ID associated with this start event. Similarly SecurityStart is mapped to Activity2Start. Note you can map many DiagnosticSource events to the same EventSource Event (e.g. Activity1Start). As long as the activities don't nest, you can reuse the same event name (since the payloads have the DiagnosticSource name which can disambiguate). However if they nest you need to use another EventSource event because the rules of EventSource activities state that a start of the same event terminates any existing activity of the same name. As its name suggests RecursiveActivity1Start, is marked as recursive and thus can be used when the activity can nest with itself. This should not be a 'top most' activity because it is not 'self healing' (if you miss a stop, then the activity NEVER ends). See the DiagnosticSourceEventSourceBridgeTest.cs for more explicit examples of using this bridge.

Indicates diagnostics messages from DiagnosticSourceEventSource should be included.

Indicates that all events from all diagnostic sources should be forwarded to the EventSource using the 'Event' event.

Used to send ad-hoc diagnostics to humans.

Events from DiagnosticSource can be forwarded to EventSource using this event.

This is only used on V4.5 systems that don't have the ability to log KeyValuePairs directly. It will eventually go away, but we should always reserve the ID for this.

Used to mark the beginning of an activity

Used to mark the end of an activity

Used to mark the beginning of an activity

Used to mark the end of an activity that can be recursive.

Used to mark the beginning of an activity

Used to mark the end of an activity that can be recursive.

Fires when a new DiagnosticSource becomes available.

Fires when the Activity start.

The ActivitySource name The Activity name Name and value pairs of the Activity properties

Fires when the Activity stop.

The ActivitySource name The Activity name Name and value pairs of the Activity properties

Called when the EventSource gets a command from a EventListener or ETW.

A function which is fully interruptible even in release code so we can stop here and do function evaluation in the debugger. Thus this is just a place that is useful for the debugger to place a breakpoint where it can inject code with function evaluation

FilterAndTransform represents on transformation specification from a DiagnosticsSource to EventSource's 'Event' method. (e.g. MySource/MyEvent:out=prop1.prop2.prop3). Its main method is 'Morph' which takes a DiagnosticSource object and morphs it into a list of string,string key value pairs. This method also contains that static 'Create/Destroy FilterAndTransformList, which simply parse a series of transformation specifications.

Parses filterAndPayloadSpecs which is a list of lines each of which has the from DiagnosticSourceName/EventName:PAYLOAD_SPEC where PAYLOADSPEC is a semicolon separated list of specifications of the form OutputName=Prop1.Prop2.PropN Into linked list of FilterAndTransform that together forward events from the given DiagnosticSource's to 'eventSource'. Sets the 'specList' variable to this value (destroying anything that was there previously). By default any serializable properties of the payload object are also included in the output payload, however this feature and be tuned off by prefixing the PAYLOADSPEC with a '-'.

This destroys (turns off) the FilterAndTransform stopping the forwarding started with CreateFilterAndTransformList

Creates one FilterAndTransform specification from filterAndPayloadSpec starting at 'startIdx' and ending just before 'endIdx'. This FilterAndTransform will subscribe to DiagnosticSources specified by the specification and forward them to 'eventSource. For convenience, the 'Next' field is set to the 'next' parameter, so you can easily form linked lists.

Transform spec represents a string that describes how to extract a piece of data from the DiagnosticSource payload. An example string is OUTSTR=EVENT_VALUE.PROP1.PROP2.PROP3 It has a Next field so they can be chained together in a linked list.

parse the strings 'spec' from startIdx to endIdx (points just beyond the last considered char) The syntax is ID1=ID2.ID3.ID4 .... Where ID1= is optional.

Given the DiagnosticSourcePayload 'obj', compute a key-value pair from it. For example if the spec is OUTSTR=EVENT_VALUE.PROP1.PROP2.PROP3 and the ultimate value of PROP3 is 10 then the return key value pair is KeyValuePair("OUTSTR","10")

A public field that can be used to form a linked list.

A PropertySpec represents information needed to fetch a property from and efficiently. Thus it represents a '.PROP' in a TransformSpec (and a transformSpec has a list of these).

Make a new PropertySpec for a property named 'propertyName'. For convenience you can set he 'next' field to form a linked list of PropertySpecs.

Given an object fetch the property that this PropertySpec represents. obj may be null when IsStatic is true, otherwise it must be non-null.

A public field that can be used to form a linked list.

PropertyFetch is a helper class. It takes a PropertyInfo and then knows how to efficiently fetch that property from a .NET object (See Fetch method). It hides some slightly complex generic code.

The type of the object that the property is fetched from. For well-known static methods that aren't actually property getters this will return null.

Create a property fetcher for a propertyName

Given an object, fetch the property that this propertyFech represents.

A fetcher that returns the result of Activity.Current

A fetcher that enumerates and formats an IEnumerable

CallbackObserver is an adapter class that creates an observer (which you can pass to IObservable.Subscribe), and calls the given callback every time the 'next' operation on the IObserver happens.

States a dependency that one member has on another.

This can be used to inform tooling of a dependency that is otherwise not evident purely from metadata and IL, for example a member relied on via reflection.

Initializes a new instance of the class with the specified signature of a member on the same type as the consumer.

The signature of the member depended on.

Initializes a new instance of the class with the specified signature of a member on a .

The signature of the member depended on. The containing .

Initializes a new instance of the class with the specified signature of a member on a type in an assembly.

The signature of the member depended on. The full name of the type containing the specified member. The assembly name of the type containing the specified member.

Initializes a new instance of the class with the specified types of members on a .

The types of members depended on. The containing the specified members.

Initializes a new instance of the class with the specified types of members on a type in an assembly.

The types of members depended on. The full name of the type containing the specified members. The assembly name of the type containing the specified members.

Gets the signature of the member depended on.

Either must be a valid string or must not equal , but not both.

Gets the which specifies the type of members depended on.

Either must be a valid string or must not equal , but not both.

Gets the containing the specified member.

If neither nor are specified, the type of the consumer is assumed.

Gets the full name of the type containing the specified member.

If neither nor are specified, the type of the consumer is assumed.

Gets the assembly name of the specified type.

is only valid when is specified.

Gets or sets the condition in which the dependency is applicable, e.g. "DEBUG".

Specifies the types of members that are dynamically accessed. This enumeration has a attribute that allows a bitwise combination of its member values.

Specifies no members.

Specifies the default, parameterless public constructor.

Specifies all public constructors.

Specifies all non-public constructors.

Specifies all public methods.

Specifies all non-public methods.

Specifies all public fields.

Specifies all non-public fields.

Specifies all public nested types.

Specifies all non-public nested types.

Specifies all public properties.

Specifies all non-public properties.

Specifies all public events.

Specifies all non-public events.

Specifies all interfaces implemented by the type.

Specifies all members.

Indicates that the specified method requires dynamic access to code that is not referenced statically, for example through .

This allows tools to understand which methods are unsafe to call when removing unreferenced code from an application.

Initializes a new instance of the class with the specified message.

A message that contains information about the usage of unreferenced code.

Gets a message that contains information about the usage of unreferenced code.

Gets or sets an optional URL that contains more information about the method, why it requries unreferenced code, and what options a consumer has to deal with it.

Suppresses reporting of a specific rule violation, allowing multiple suppressions on a single code artifact.

is different than in that it doesn't have a . So it is always preserved in the compiled assembly.

Initializes a new instance of the class, specifying the category of the tool and the identifier for an analysis rule.

The category for the attribute. The identifier of the analysis rule the attribute applies to.

Gets the category identifying the classification of the attribute.

The property describes the tool or tool analysis category for which a message suppression attribute applies.

Gets the identifier of the analysis tool rule to be suppressed.

Concatenated together, the and properties form a unique check identifier.

Gets or sets the scope of the code that is relevant for the attribute.

The Scope property is an optional argument that specifies the metadata scope for which the attribute is relevant.

Gets or sets a fully qualified path that represents the target of the attribute.

The property is an optional argument identifying the analysis target of the attribute. An example value is "System.IO.Stream.ctor():System.Void". Because it is fully qualified, it can be long, particularly for targets such as parameters. The analysis tool user interface should be capable of automatically formatting the parameter.

Gets or sets an optional argument expanding on exclusion criteria.

The property is an optional argument that specifies additional exclusion where the literal metadata target is not sufficiently precise. For example, the cannot be applied within a method, and it may be desirable to suppress a violation against a statement in the method that will give a rule violation, but not against all statements in the method.

Gets or sets the justification for suppressing the code analysis message.

Specifies that null is allowed as an input even if the corresponding type disallows it.

Specifies that null is disallowed as an input even if the corresponding type allows it.

Specifies that an output may be null even if the corresponding type disallows it.

Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.

Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it.

Initializes the attribute with the specified return value condition.

The return value condition. If the method returns this value, the associated parameter may be null.

Gets the return value condition.

Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it.

Initializes the attribute with the specified return value condition.

The return value condition. If the method returns this value, the associated parameter will not be null.

Gets the return value condition.

Specifies that the output will be non-null if the named parameter is non-null.

Initializes the attribute with the associated parameter name.

The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null.

Gets the associated parameter name.

Applied to a method that will never return under any circumstance.

Specifies that the method will not return if the associated Boolean parameter is passed the specified value.

Initializes the attribute with the specified parameter value.

The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to the associated parameter matches this value.

Gets the condition parameter value.

Specifies that the method or property will ensure that the listed field and property members have not-null values.

Initializes the attribute with a field or property member.

The field or property member that is promised to be not-null.

Initializes the attribute with the list of field and property members.

The list of field and property members that are promised to be not-null.

Gets field or property member names.

Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.

Initializes the attribute with the specified return value condition and a field or property member.

The return value condition. If the method returns this value, the associated parameter will not be null. The field or property member that is promised to be not-null.

Initializes the attribute with the specified return value condition and list of field and property members.

The return value condition. If the method returns this value, the associated parameter will not be null. The list of field and property members that are promised to be not-null.

Gets the return value condition.

Gets field or property member names.

Activity represents operation with context to be used for logging. Activity has operation name, Id, start time and duration, tags and baggage. Current activity can be accessed with static AsyncLocal variable Activity.Current. Activities should be created with constructor, configured as necessary and then started with Activity.Start method which maintains parent-child relationships for the activities and sets Activity.Current. When activity is finished, it should be stopped with static Activity.Stop method. No methods on Activity allow exceptions to escape as a response to bad inputs. They are thrown and caught (that allows Debuggers and Monitors to see the error) but the exception is suppressed, and the operation does something reasonable (typically doing nothing).

Normally if the ParentID is defined, the format of that is used to determine the format used by the Activity. However if ForceDefaultFormat is set to true, the ID format will always be the DefaultIdFormat even if the ParentID is define and is a different format.

Gets status code of the current activity object.

Gets the status description of the current activity object.

Sets the status code and description on the current activity object.

The status code The error status description for convenient chaining. When passing code value different than ActivityStatusCode.Error, the Activity.StatusDescription will reset to null value. The description paramater will be respected only when passing ActivityStatusCode.Error value.

Gets the relationship between the Activity, its parents, and its children in a Trace.

An operation name is a COARSEST name that is useful grouping/filtering. The name is typically a compile-time constant. Names of Rest APIs are reasonable, but arguments (e.g. specific accounts etc), should not be in the name but rather in the tags.

Gets or sets the display name of the Activity

DisplayName is intended to be used in a user interface and need not be the same as OperationName.

Get the ActivitySource object associated with this Activity.

All Activities created from public constructors will have a singleton source where the source name is an empty string. Otherwise, the source will hold the object that created the Activity through ActivitySource.StartActivity.

If the Activity that created this activity is from the same process you can get that Activity with Parent. However, this can be null if the Activity has no parent (a root activity) or if the Parent is from outside the process.

If the Activity has ended ( or was called) then this is the delta between and end. If Activity is not ended and was not called then this is .

The time that operation started. It will typically be initialized when is called, but you can set at any time via .

This is an ID that is specific to a particular request. Filtering to a particular ID insures that you get only one request that matches. Id has a hierarchical structure: '|root-id.id1_id2.id3_' Id is generated when is called by appending suffix to Parent.Id or ParentId; Activity has no Id until it started See for more details

Id looks like '|a000b421-5d183ab6.1.8e2d4c28_1.': - '|a000b421-5d183ab6.' - Id of the first, top-most, Activity created - '|a000b421-5d183ab6.1.' - Id of a child activity. It was started in the same process as the first activity and ends with '.' - '|a000b421-5d183ab6.1.8e2d4c28_' - Id of the grand child activity. It was started in another process and ends with '_' 'a000b421-5d183ab6' is a for the first Activity and all its children

If the parent for this activity comes from outside the process, the activity does not have a Parent Activity but MAY have a ParentId (which was deserialized from from the parent). This accessor fetches the parent ID if it exists at all. Note this can be null if this is a root Activity (it has no parent) See for more details

Root Id is substring from Activity.Id (or ParentId) between '|' (or beginning) and first '.'. Filtering by root Id allows to find all Activities involved in operation processing. RootId may be null if Activity has neither ParentId nor Id. See for more details

Tags are string-string key-value pairs that represent information that will be logged along with the Activity to the logging system. This information however is NOT passed on to the children of this activity.

List of the tags which represent information that will be logged along with the Activity to the logging system. This information however is NOT passed on to the children of this activity.

Events is the list of all objects attached to this Activity object. If there is not any object attached to the Activity object, Events will return empty list.

Links is the list of all objects attached to this Activity object. If there is no any object attached to the Activity object, Links will return empty list.

Baggage is string-string key-value pairs that represent information that will be passed along to children of this activity. Baggage is serialized when requests leave the process (along with the ID). Typically Baggage is used to do fine-grained control over logging of the activity and any children. In general, if you are not using the data at runtime, you should be using Tags instead.

Returns the value of the key-value pair added to the activity with . Returns null if that key does not exist.

Returns the value of the Activity tag mapped to the input key/>. Returns null if that key does not exist.

The tag key string. The tag value mapped to the input key.

Note that Activity has a 'builder' pattern, where you call the constructor, a number of 'Set*' and 'Add*' APIs and then call to build the activity. You MUST call before using it.

Operation's name

Update the Activity to have a tag with an additional 'key' and value 'value'. This shows up in the enumeration. It is meant for information that is useful to log but not needed for runtime control (for the latter, )

for convenient chaining. The tag key name The tag value mapped to the input key

Add or update the Activity tag with the input key and value. If the input value is null - if the collection has any tag with the same key, then this tag will get removed from the collection. - otherwise, nothing will happen and the collection will not change. If the input value is not null - if the collection has any tag with the same key, then the value mapped to this key will get updated with the new input value. - otherwise, the key and value will get added as a new tag to the collection.

The tag key name The tag value mapped to the input key for convenient chaining.

Add object to the list.

object of to add to the attached events list. for convenient chaining.

Update the Activity to have baggage with an additional 'key' and value 'value'. This shows up in the enumeration as well as the method. Baggage is meant for information that is needed for runtime control. For information that is simply useful to show up in the log with the activity use . Returns 'this' for convenient chaining.

for convenient chaining.

Add or update the Activity baggage with the input key and value. If the input value is null - if the collection has any baggage with the same key, then this baggage will get removed from the collection. - otherwise, nothing will happen and the collection will not change. If the input value is not null - if the collection has any baggage with the same key, then the value mapped to this key will get updated with the new input value. - otherwise, the key and value will get added as a new baggage to the collection.

The baggage key name The baggage value mapped to the input key for convenient chaining.

Updates the Activity To indicate that the activity with ID caused this activity. This is intended to be used only at 'boundary' scenarios where an activity from another process logically started this activity. The Parent ID shows up the Tags (as well as the ParentID property), and can be used to reconstruct the causal tree. Returns 'this' for convenient chaining.

The id of the parent operation.

Set the parent ID using the W3C convention using a TraceId and a SpanId. This constructor has the advantage that no string manipulation is needed to set the ID.

Update the Activity to set start time

Activity start time in UTC (Greenwich Mean Time) for convenient chaining.

Update the Activity to set as a difference between and .

Activity stop time in UTC (Greenwich Mean Time) for convenient chaining.

Get the context of the activity. Context becomes valid only if the activity has been started. otherwise will default context.

Starts activity Sets to hold . Sets to this activity. If was not set previously, sets it to . Generates a unique for this activity. Use to start activity and write start event.

Stops activity: sets to . If end time was not set previously, sets as a difference between and Use to stop activity and write stop event.

Holds the W3C 'tracestate' header as a string. Tracestate is intended to carry information supplemental to trace identity contained in traceparent. List of key value pairs carried by tracestate convey information about request position in multiple distributed tracing graphs. It is typically used by distributed tracing systems and should not be used as a general purpose baggage as this use may break correlation of a distributed trace. Logically it is just a kind of baggage (if flows just like baggage), but because it is expected to be special cased (it has its own HTTP header), it is more convenient/efficient if it is not lumped in with other baggage.

If the Activity has the W3C format, this returns the ID for the SPAN part of the Id. Otherwise it returns a zero SpanId.

If the Activity has the W3C format, this returns the ID for the TraceId part of the Id. Otherwise it returns a zero TraceId.

True if the W3CIdFlags.Recorded flag is set.

Indicate if the this Activity object should be populated with all the propagation info and also all other properties such as Links, Tags, and Events.

Return the flags (defined by the W3C ID specification) associated with the activity.

If the parent Activity ID has the W3C format, this returns the ID for the SpanId part of the ParentId. Otherwise it returns a zero SpanId.

When starting an Activity which does not have a parent context, the Trace Id will automatically be generated using random numbers. TraceIdGenerator can be used to override the runtime's default Trace Id generation algorithm.

- TraceIdGenerator needs to be set only if the default Trace Id generation is not enough for the app scenario. - When setting TraceIdGenerator, ensure it is performant enough to avoid any slowness in the Activity starting operation. - If TraceIdGenerator is set multiple times, the last set will be the one used for the Trace Id generation. - Setting TraceIdGenerator to null will re-enable the default Trace Id generation algorithm.

Activity tries to use the same format for IDs as its parent. However if the activity has no parent, it has to do something. This determines the default format we use.

Sets IdFormat on the Activity before it is started. It takes precedence over Parent.IdFormat, ParentId format, DefaultIdFormat and ForceDefaultIdFormat.

Returns true if 'id' has the format of a WC3 id see https://w3c.github.io/trace-context

Dispose will stop the Activity if it is already started and notify any event listeners. Nothing will happen otherwise.

SetCustomProperty allow attaching any custom object to this Activity object. If the property name was previously associated with other object, SetCustomProperty will update to use the new propert value instead.

The name to associate the value with. The object to attach and map to the property name.

GetCustomProperty retrieve previously attached object mapped to the property name.

The name to get the associated object with. The object mapped to the property name. Or null if there is no mapping previously done with this property name.

Set the ID (lazily, avoiding strings if possible) to a W3C ID (using the traceId from the parent if possible

Returns a new ID using the Hierarchical Id

Returns the format for the ID.

Gets or sets the current operation (Activity) for the current thread. This flows across async calls.

Returns high resolution (1 DateTime tick) current UTC DateTime.

These flags are defined by the W3C standard along with the ID for the activity.

The possibilities for the format of the ID

A TraceId is the format the W3C standard requires for its ID for the entire trace. It represents 16 binary bytes of information, typically displayed as 32 characters of Hexadecimal. A TraceId is a STRUCT, and does contain the 16 bytes of binary information so there is value in passing it by reference. It does know how to convert to and from its Hexadecimal string representation, tries to avoid changing formats until it has to, and caches the string representation after it was created. It is mostly useful as an exchange type.

Create a new TraceId with at random number in it (very likely to be unique)

Returns the TraceId as a 32 character hexadecimal string.

This is exposed as CreateFromUtf8String, but we are modifying fields, so the code needs to be in a constructor.

Copy the bytes of the TraceId (16 total) into the 'destination' span.

Sets the bytes in 'outBytes' to be random values. outBytes.Length must be either 8 or 16 bytes.

Converts 'idData' which is assumed to be HEX Unicode characters to binary puts it in 'outBytes'

A SpanId is the format the W3C standard requires for its ID for a single span in a trace. It represents 8 binary bytes of information, typically displayed as 16 characters of Hexadecimal. A SpanId is a STRUCT, and does contain the 8 bytes of binary information so there is value in passing it by reference. It does know how to convert to and from its Hexadecimal string representation, tries to avoid changing formats until it has to, and caches the string representation after it was created. It is mostly useful as an exchange type.

Create a new SpanId with at random number in it (very likely to be unique)

Returns the SpanId as a 16 character hexadecimal string.

Returns SpanId as a hex string.

Copy the bytes of the TraceId (8 bytes total) into the 'destination' span.

Define the status code of the Activity which indicate the status of the instrumented operation.

Unset status code is the default value indicating the status code is not initialized.

Status code indicating the operation has been validated and completed successfully.

Status code indicating an error is encountered during the operation.

ActivityTagsCollection is a collection class used to store tracing tags. This collection will be used with classes like and . This collection behaves as follows: - The collection items will be ordered according to how they are added. - Don't allow duplication of items with the same key. - When using the indexer to store an item in the collection: - If the item has a key that previously existed in the collection and the value is null, the collection item matching the key will be removed from the collection. - If the item has a key that previously existed in the collection and the value is not null, the new item value will replace the old value stored in the collection. - Otherwise, the item will be added to the collection. - Add method will add a new item to the collection if an item doesn't already exist with the same key. Otherwise, it will throw an exception.

Create a new instance of the collection.

Create a new instance of the collection and store the input list items in the collection.

Initial list to store in the collection.

Get or set collection item When setting a value to this indexer property, the following behavior will be observed: - If the key previously existed in the collection and the value is null, the collection item matching the key will get removed from the collection. - If the key previously existed in the collection and the value is not null, the value will replace the old value stored in the collection. - Otherwise, a new item will get added to the collection.

Object mapped to the key

Get the list of the keys of all stored tags.

Get the list of the values of all stored tags.

Gets a value indicating whether the collection is read-only.

Gets the number of elements contained in the collection.

Adds a tag with the provided key and value to the collection. This collection doesn't allow adding two tags with the same key.

The tag key. The tag value.

Adds an item to the collection

Key and value pair of the tag to add to the collection.

Removes all items from the collection.

Determines whether the collection contains an element with the specified key.

True if the collection contains tag with that key. False otherwise.

Copies the elements of the collection to an array, starting at a particular array index.

The array that is the destination of the elements copied from collection. The zero-based index in array at which copying begins.

Returns an enumerator that iterates through the collection.

Removes the tag with the specified key from the collection.

The tag key True if the item existed and removed. False otherwise.

Removes the first occurrence of a specific item from the collection.

The tag key value pair to remove. True if item was successfully removed from the collection; otherwise, false. This method also returns false if item is not found in the original collection.

Gets the value associated with the specified key.

The tag key. The tag value. When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.

FindIndex finds the index of item in the list having a key matching the input key. We didn't use List.FindIndex to avoid the extra allocation caused by the closure when calling the Predicate delegate.

The key to search the item in the list The index of the found item, or -1 if the item not found.

ActivityContext representation conforms to the w3c TraceContext specification. It contains two identifiers a TraceId and a SpanId - along with a set of common TraceFlags and system-specific TraceState values.

Construct a new object of ActivityContext.

A trace identifier. A span identifier. Contain details about the trace. Carries system-specific configuration data. Indicate the context is propagated from remote parent. isRemote is not a part of W3C specification. It is needed for the OpenTelemetry scenarios.

The trace identifier

The span identifier

These flags are defined by the W3C standard along with the ID for the activity.

Holds the W3C 'tracestate' header as a string.

IsRemote indicates if the ActivityContext was propagated from a remote parent.

IsRemote is not a part of W3C specification. It is needed for the OpenTelemetry scenarios.

Parse W3C trace context headers to ActivityContext object.

W3C trace parent header. W3C trace state. The ActivityContext object created from the parsing operation.

Parse W3C trace context headers to ActivityContext object.

W3C trace parent header. Trace state. The ActivityContext object created from the parsing operation.

ActivityCreationOptions is encapsulating all needed information which will be sent to the ActivityListener to decide about creating the Activity object and with what state. The possible generic type parameters is or

Construct a new object.

The trace Activity source used to request creating the Activity object. The operation name of the Activity. The requested parent to create the Activity object with. The parent either be a parent Id represented as string or it can be a parent context . to create the Activity object with. Key-value pairs list for the tags to create the Activity object with. list to create the Activity object with. The default Id format to use.

Retrieve the object.

Retrieve the name which requested to create the Activity object with.

Retrieve the which requested to create the Activity object with.

Retrieve the parent which requested to create the Activity object with. Parent will be either in form of string or .

Retrieve the tags which requested to create the Activity object with.

Retrieve the list of which requested to create the Activity object with.

Retrieve Id format of to use for the Activity we may create.

Used by ActivityListener to indicate what amount of data should be collected for this Activity Requesting more data causes greater performance overhead to collect it.

The Activity object doesn't need to be created

The Activity object needs to be created. It will have Name, Source, Id and Baggage. Other properties are unnecessary and will be ignored by this listener.

The activity object should be populated with all the propagation info and also all other properties such as Links, Tags, and Events. Activity.IsAllDataRequested will return true.

The activity object should be populated the same as the AllData case and additionally Activity.IsRecorded is set true. For activities using W3C trace ids this sets a flag bit in the ID that will be propagated downstream requesting that trace is recorded everywhere.

A text annotation associated with a collection of tags.

Initializes a new instance of the class.

Event name.

Initializes a new instance of the class.

Event name. Event timestamp. Timestamp MUST only be used for the events that happened in the past, not at the moment of this call. Event Tags.

Gets the name.

Gets the timestamp.

Gets the collection of tags associated with the event.

Kind describes the relationship between the Activity, its parents, and its children in a Trace. -------------------------------------------------------------------------------- ActivityKind Synchronous Asynchronous Remote Incoming Remote Outgoing -------------------------------------------------------------------------------- Internal Client yes yes Server yes yes Producer yes maybe Consumer yes maybe --------------------------------------------------------------------------------

Default value. Indicates that the Activity represents an internal operation within an application, as opposed to an operations with remote parents or children.

Server activity represents request incoming from external component.

Client activity represents outgoing request to the external component.

Producer activity represents output provided to external components.

Consumer activity represents output received from an external component.

Activity may be linked to zero or more other that are causally related. Links can point to ActivityContexts inside a single Trace or across different Traces. Links can be used to represent batched operations where a Activity was initiated by multiple initiating Activities, each representing a single incoming item being processed in the batch.

Construct a new object which can be linked to an Activity object.

The trace Activity context The key-value pair list of tags which associated to the

Retrieve the object inside this object.

Retrieve the key-value pair list of tags attached with the .

Define the callback that can be used in to allow deciding to create the Activity objects and with what data state.

ActivityListener allows listening to the start and stop Activity events and give the oppertunity to decide creating the Activity for sampling scenarios.

Construct a new object to start listening to the events.

Set or get the callback used to listen to the start event.

Set or get the callback used to listen to the stop event.

Set or get the callback used to decide if want to listen to objects events which created using object.

Set or get the callback used to decide allowing creating objects with specific data state.

Dispose will unregister this object from listening to events.

Construct an ActivitySource object with the input name

The name of the ActivitySource object The version of the component publishing the tracing info.

Returns the ActivitySource name.

Returns the ActivitySource version.

Check if there is any listeners for this ActivitySource. This property can be helpful to tell if there is no listener, then no need to create Activity object and avoid creating the objects needed to create Activity (e.g. ActivityContext) Example of that is http scenario which can avoid reading the context data from the wire.

Creates a new object if there is any listener to the Activity, returns null otherwise.

The operation name of the Activity The The created object or null if there is no any event listener. If the Activity object is created, it will not start automatically. Callers need to call to start it.

Creates a new object if there is any listener to the Activity, returns null otherwise. If the Activity object is created, it will not automatically start. Callers will need to call to start it.

The operation name of the Activity. The The parent object to initialize the created Activity object with. The optional tags list to initialize the created Activity object with. The optional list to initialize the created Activity object with. The default Id format to use. The created object or null if there is no any listener. If the Activity object is created, it will not start automatically. Callers need to call to start it.

Creates a new object if there is any listener to the Activity, returns null otherwise.

The operation name of the Activity. The The parent Id to initialize the created Activity object with. The optional tags list to initialize the created Activity object with. The optional list to initialize the created Activity object with. The default Id format to use. The created object or null if there is no any listener. If the Activity object is created, it will not start automatically. Callers need to call to start it.

Creates and starts a new object if there is any listener to the Activity, returns null otherwise.

The operation name of the Activity The The created object or null if there is no any event listener.

Creates and starts a new object if there is any listener to the Activity events, returns null otherwise.

The operation name of the Activity. The The parent object to initialize the created Activity object with. The optional tags list to initialize the created Activity object with. The optional list to initialize the created Activity object with. The optional start timestamp to set on the created Activity object. The created object or null if there is no any listener.

Creates and starts a new object if there is any listener to the Activity events, returns null otherwise.

The operation name of the Activity. The The parent Id to initialize the created Activity object with. The optional tags list to initialize the created Activity object with. The optional list to initialize the created Activity object with. The optional start timestamp to set on the created Activity object. The created object or null if there is no any listener.

Creates and starts a new object if there is any listener to the Activity events, returns null otherwise.

The The parent object to initialize the created Activity object with. The optional tags list to initialize the created Activity object with. The optional list to initialize the created Activity object with. The optional start timestamp to set on the created Activity object. The operation name of the Activity. The created object or null if there is no any listener.

Dispose the ActivitySource object and remove the current instance from the global list. empty the listeners list too.

Add a listener to the starting and stopping events.

The object to use for listening to the events.

An implementation of DistributedContextPropagator determines if and how distributed context information is encoded and decoded as it traverses the network. The encoding can be transported over any network protocol that supports string key-value pairs. For example when using HTTP, each key value pair is an HTTP header. DistributedContextPropagator inject values into and extracts values from carriers as string key/value pairs.

The callback that is used in propagators' extract methods. The callback is invoked to lookup the value of a named field.

Carrier is the medium used by Propagators to read values from. The propagation field name. An output string to receive the value corresponds to the input fieldName. This should return non null value if there is only one value for the input field name. An output collection of strings to receive the values corresponds to the input fieldName. This should return non null value if there are more than one value for the input field name.

The callback that is used in propagators' inject methods. This callback is invoked to set the value of a named field. Propagators may invoke it multiple times in order to set multiple fields.

Carrier is the medium used by Propagators to write values to. The propagation field name. The value corresponds to the input fieldName.

The set of field names this propagator is likely to read or write.

Returns list of fields that will be used by the DistributedContextPropagator.

Injects the trace values stroed in the object into a carrier. For example, into the headers of an HTTP request.

The Activity object has the distributed context to inject to the carrier. Carrier is the medium in which the distributed context will be stored. The callback will be invoked to set a named key/value pair on the carrier.

Extracts trace Id and trace state from an incoming request represented by the carrier. For example, from the headers of an HTTP request.

Carrier is the medium from which values will be read. The callback will be invoked to get the propagation trace Id and trace state from carrier. The extracted trace Id from the carrier. The extracted trace state from the carrier.

Extracts the baggage key-value pair list from an incoming request represented by the carrier. For example, from the headers of an HTTP request.

Carrier is the medium from which values will be read. The callback will be invoked to get the propagation baggage list from carrier. Returns the extracted key-value pair list from the carrier.

Get or set the process wide propagator object which used as the current selected propagator.

returns the default propagator object which Current property will be initialized with.

CreateDefaultPropagator will create a propagator instance that can inject and extract the headers with field names "tracestate", "traceparent" of the identifiers which are formatted as W3C trace parent, "Request-Id" of the identifiers which are formatted as a hierarchical identifier. The returned propagator can inject the baggage key-value pair list with header name "Correlation-Context" and it can extract the baggage values mapped to header names "Correlation-Context" and "baggage".

Returns a propagator which attempts to act transparently, emitting the same data on outbound network requests that was received on the in-bound request. When encoding the outbound message, this propagator uses information from the request's root Activity, ignoring any intermediate Activities that may have been created while processing the request.

Returns a propagator which does not transmit any distributed context information in outbound network messages.

RandomNumberGenerator implementation is the 64-bit random number generator based on the Xoshiro256StarStar algorithm (known as shift-register generators).

AggregatorStore is a high performance map from an unordered list of labels (KeyValuePairs) to an instance of TAggregator

The type of Aggregator returned by the store

The counter is an instrument that supports adding non-negative values. For example you might call counter.Add(1) each time a request is processed to track the total number of requests. Most metric viewers will display counters using a rate by default (requests/sec) but can also display a cumulative total.

This class supports only the following generic parameter types: , , , , , , and

Record the increment value of the measurement.

The increment measurement.

Record the increment value of the measurement.

The increment measurement. A key-value pair tag associated with the measurement.

Record the increment value of the measurement.

The increment measurement. A first key-value pair tag associated with the measurement. A second key-value pair tag associated with the measurement.

Record the increment value of the measurement.

The increment measurement. A first key-value pair tag associated with the measurement. A second key-value pair tag associated with the measurement. A third key-value pair tag associated with the measurement.

Record the increment value of the measurement.

The increment measurement. A span of key-value pair tags associated with the measurement.

Record the increment value of the measurement.

The increment measurement. A list of key-value pair tags associated with the measurement.

Record the increment value of the measurement.

The measurement value. A of tags associated with the measurement.

The histogram is a metrics Instrument which can be used to report arbitrary values that are likely to be statistically meaningful. e.g. the request duration. Use method to create the Histogram object.

This class supports only the following generic parameter types: , , , , , , and

Record a measurement value.

The measurement value.

Record a measurement value.

The measurement value. A key-value pair tag associated with the measurement.

Record a measurement value.

The measurement value. A first key-value pair tag associated with the measurement. A second key-value pair tag associated with the measurement.

Record a measurement value.

The measurement value. A first key-value pair tag associated with the measurement. A second key-value pair tag associated with the measurement. A third key-value pair tag associated with the measurement.

Record a measurement value.

The measurement value. A span of key-value pair tags associated with the measurement.

Record a measurement value.

The measurement value. A list of key-value pair tags associated with the measurement.

Record a measurement value.

The measurement value. A of tags associated with the measurement.

Base class of all Metrics Instrument classes

Protected constructor to initialize the common instrument properties like the meter, name, description, and unit. All classes extending Instrument need to call this constructor when constructing object of the extended class.

The meter that created the instrument. The instrument name. cannot be null. Optional instrument unit of measurements. Optional instrument description.

Publish is activating the instrument to start recording measurements and to allow listeners to start listening to such measurements.

Gets the Meter which created the instrument.

Gets the instrument name.

Gets the instrument description.

Gets the instrument unit of measurements.

Checks if there is any listeners for this instrument.

A property tells if the instrument is an observable instrument.

Instrument{T} is the base class for all non-observable instruments.

This class supports only the following generic parameter types: , , , , , , and

Instrument{T} is the base class from which all non-observable instruments will inherit from.

This class supports only the following generic parameter types: , , , , , , and

Create the metrics instrument using the properties meter, name, description, and unit. All classes extending Instrument{T} need to call this constructor when constructing object of the extended class.

The meter that created the instrument. The instrument name. cannot be null. Optional instrument unit of measurements. Optional instrument description.

Record the measurement by notifying all objects which listening to this instrument.