mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Activities System.Activities.DurableInstancing System.Activities.Presentation System.Runtime.DurableInstancing System.Workflow.Activities System.Workflow.ComponentModel System.Workflow.Runtime System.WorkflowServices System.Xaml.Hosting XamlBuildTask
2572 lines
152 KiB
C#
2572 lines
152 KiB
C#
//------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Activities
|
|
{
|
|
using System.Runtime;
|
|
using System.Runtime.Diagnostics;
|
|
using System.Security;
|
|
|
|
|
|
internal partial class TD
|
|
{
|
|
|
|
static System.Resources.ResourceManager resourceManager;
|
|
|
|
static System.Globalization.CultureInfo resourceCulture;
|
|
|
|
[System.Security.SecurityCriticalAttribute()]
|
|
static System.Runtime.Diagnostics.EventDescriptor[] eventDescriptors;
|
|
|
|
static object syncLock = new object();
|
|
|
|
// Double-checked locking pattern requires volatile for read/write synchronization
|
|
static volatile bool eventDescriptorsCreated;
|
|
|
|
private TD()
|
|
{
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification="This is an auto-generated code, some ETW/TraceSource mixed code would use it.")]
|
|
static System.Resources.ResourceManager ResourceManager
|
|
{
|
|
get
|
|
{
|
|
if (object.ReferenceEquals(resourceManager, null))
|
|
{
|
|
resourceManager = new System.Resources.ResourceManager("System.Activities.TD", typeof(TD).Assembly);
|
|
}
|
|
return resourceManager;
|
|
}
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification="This template is shared across all assemblies, some of which use this accessor.")]
|
|
internal static System.Globalization.CultureInfo Culture
|
|
{
|
|
get
|
|
{
|
|
return resourceCulture;
|
|
}
|
|
set
|
|
{
|
|
resourceCulture = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=39456, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool TrackingRecordDroppedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}
|
|
/// Event description ID=39456, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="RecordNumber">Parameter 0 for event: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}</param>
|
|
/// <param name="ProviderId">Parameter 1 for event: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}</param>
|
|
internal static void TrackingRecordDropped(long RecordNumber, System.Guid ProviderId)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(0))
|
|
{
|
|
TD.WriteEtwEvent(0, null, RecordNumber, ProviderId, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=39457, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool TrackingRecordRaisedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(1)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Tracking Record {0} raised to {1}.
|
|
/// Event description ID=39457, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Tracking Record {0} raised to {1}.</param>
|
|
/// <param name="param1">Parameter 1 for event: Tracking Record {0} raised to {1}.</param>
|
|
internal static void TrackingRecordRaised(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(1))
|
|
{
|
|
TD.WriteEtwEvent(1, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("TrackingRecordRaised", Culture), param0, param1);
|
|
TD.WriteTraceSource(1, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=39458, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool TrackingRecordTruncatedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(2));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed
|
|
/// Event description ID=39458, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="RecordNumber">Parameter 0 for event: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed</param>
|
|
/// <param name="ProviderId">Parameter 1 for event: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed</param>
|
|
internal static void TrackingRecordTruncated(long RecordNumber, System.Guid ProviderId)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(2))
|
|
{
|
|
TD.WriteEtwEvent(2, null, RecordNumber, ProviderId, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=39459, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool TrackingDataExtractedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(3)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Tracking data {0} extracted in activity {1}.
|
|
/// Event description ID=39459, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="Data">Parameter 0 for event: Tracking data {0} extracted in activity {1}.</param>
|
|
/// <param name="Activity">Parameter 1 for event: Tracking data {0} extracted in activity {1}.</param>
|
|
internal static void TrackingDataExtracted(string Data, string Activity)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(3))
|
|
{
|
|
TD.WriteEtwEvent(3, null, Data, Activity, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("TrackingDataExtracted", Culture), Data, Activity);
|
|
TD.WriteTraceSource(3, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1223, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool SwitchCaseNotFoundIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(4)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The Switch activity '{0}' could not find a Case activity matching the Expression result.
|
|
/// Event description ID=1223, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: The Switch activity '{0}' could not find a Case activity matching the Expression result.</param>
|
|
internal static void SwitchCaseNotFound(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(4))
|
|
{
|
|
TD.WriteEtwEvent(4, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("SwitchCaseNotFound", Culture), param0);
|
|
TD.WriteTraceSource(4, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2576, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool TryCatchExceptionFromTryIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(5)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The TryCatch activity '{0}' has caught an exception of type '{1}'.
|
|
/// Event description ID=2576, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: The TryCatch activity '{0}' has caught an exception of type '{1}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: The TryCatch activity '{0}' has caught an exception of type '{1}'.</param>
|
|
internal static void TryCatchExceptionFromTry(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(5))
|
|
{
|
|
TD.WriteEtwEvent(5, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionFromTry", Culture), param0, param1);
|
|
TD.WriteTraceSource(5, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2577, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool TryCatchExceptionDuringCancelationIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning
|
|
&& (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(6)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A child activity of the TryCatch activity '{0}' has thrown an exception during cancelation.
|
|
/// Event description ID=2577, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A child activity of the TryCatch activity '{0}' has thrown an exception during cancelation.</param>
|
|
internal static void TryCatchExceptionDuringCancelation(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(6))
|
|
{
|
|
TD.WriteEtwEvent(6, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceWarningToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionDuringCancelation", Culture), param0);
|
|
TD.WriteTraceSource(6, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2578, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool TryCatchExceptionFromCatchOrFinallyIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning
|
|
&& (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(7)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A Catch or Finally activity that is associated with the TryCatch activity '{0}' has thrown an exception.
|
|
/// Event description ID=2578, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A Catch or Finally activity that is associated with the TryCatch activity '{0}' has thrown an exception.</param>
|
|
internal static void TryCatchExceptionFromCatchOrFinally(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(7))
|
|
{
|
|
TD.WriteEtwEvent(7, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceWarningToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionFromCatchOrFinally", Culture), param0);
|
|
TD.WriteTraceSource(7, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1023, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteBookmarkWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(8)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.
|
|
/// Event description ID=1023, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param1">Parameter 1 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param2">Parameter 2 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param3">Parameter 3 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param4">Parameter 4 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
internal static void CompleteBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(8))
|
|
{
|
|
TD.WriteEtwEvent(8, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
|
|
TD.WriteTraceSource(8, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1019, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteCancelActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(9)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1019, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void CompleteCancelActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(9))
|
|
{
|
|
TD.WriteEtwEvent(9, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteCancelActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(9, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1016, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteCompletionWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(10)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1016, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
internal static void CompleteCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(10))
|
|
{
|
|
TD.WriteEtwEvent(10, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(10, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1013, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteExecuteActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(11)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1013, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void CompleteExecuteActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(11))
|
|
{
|
|
TD.WriteEtwEvent(11, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteExecuteActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(11, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1031, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteFaultWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(12)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1031, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void CompleteFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(12))
|
|
{
|
|
TD.WriteEtwEvent(12, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(12, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1034, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteRuntimeWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(13)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1034, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void CompleteRuntimeWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(13))
|
|
{
|
|
TD.WriteEtwEvent(13, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteRuntimeWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(13, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1028, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompleteTransactionContextWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(14)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1028, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void CompleteTransactionContextWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(14))
|
|
{
|
|
TD.WriteEtwEvent(14, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompleteTransactionContextWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(14, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1020, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CreateBookmarkIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(15)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.
|
|
/// Event description ID=1020, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param1">Parameter 1 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param2">Parameter 2 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param3">Parameter 3 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param4">Parameter 4 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
internal static void CreateBookmark(string param0, string param1, string param2, string param3, string param4)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(15))
|
|
{
|
|
TD.WriteEtwEvent(15, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CreateBookmark", Culture), param0, param1, param2, param3, param4);
|
|
TD.WriteTraceSource(15, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1024, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CreateBookmarkScopeIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(16)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A BookmarkScope has been created: {0}.
|
|
/// Event description ID=1024, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A BookmarkScope has been created: {0}.</param>
|
|
internal static void CreateBookmarkScope(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(16))
|
|
{
|
|
TD.WriteEtwEvent(16, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CreateBookmarkScope", Culture), param0);
|
|
TD.WriteTraceSource(16, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1038, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool EnterNoPersistBlockIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(17)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Entering a no persist block.
|
|
/// Event description ID=1038, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static void EnterNoPersistBlock()
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(17))
|
|
{
|
|
TD.WriteEtwEvent(17, null, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("EnterNoPersistBlock", Culture));
|
|
TD.WriteTraceSource(17, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1039, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ExitNoPersistBlockIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(18)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Exiting a no persist block.
|
|
/// Event description ID=1039, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static void ExitNoPersistBlock()
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(18))
|
|
{
|
|
TD.WriteEtwEvent(18, null, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ExitNoPersistBlock", Culture));
|
|
TD.WriteTraceSource(18, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1040, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool InArgumentBoundIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(19)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.
|
|
/// Event description ID=1040, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
|
|
/// <param name="param1">Parameter 1 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
|
|
/// <param name="param2">Parameter 2 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
|
|
/// <param name="param3">Parameter 3 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
|
|
/// <param name="param4">Parameter 4 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
|
|
internal static void InArgumentBound(string param0, string param1, string param2, string param3, string param4)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(19))
|
|
{
|
|
TD.WriteEtwEvent(19, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InArgumentBound", Culture), param0, param1, param2, param3, param4);
|
|
TD.WriteTraceSource(19, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1037, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool RuntimeTransactionCompleteIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(20)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The runtime transaction has completed with the state '{0}'.
|
|
/// Event description ID=1037, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: The runtime transaction has completed with the state '{0}'.</param>
|
|
internal static void RuntimeTransactionComplete(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(20))
|
|
{
|
|
TD.WriteEtwEvent(20, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionComplete", Culture), param0);
|
|
TD.WriteTraceSource(20, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1036, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool RuntimeTransactionCompletionRequestedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(21)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.
|
|
/// Event description ID=1036, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
|
|
/// <param name="param1">Parameter 1 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
|
|
/// <param name="param2">Parameter 2 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
|
|
internal static void RuntimeTransactionCompletionRequested(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(21))
|
|
{
|
|
TD.WriteEtwEvent(21, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionCompletionRequested", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(21, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1035, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool RuntimeTransactionSetIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(22)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1035, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
internal static void RuntimeTransactionSet(string param0, string param1, string param2, string param3, string param4, string param5)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(22))
|
|
{
|
|
TD.WriteEtwEvent(22, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionSet", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(22, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1021, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleBookmarkWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(23)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.
|
|
/// Event description ID=1021, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param1">Parameter 1 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param2">Parameter 2 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param3">Parameter 3 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param4">Parameter 4 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
internal static void ScheduleBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(23))
|
|
{
|
|
TD.WriteEtwEvent(23, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
|
|
TD.WriteTraceSource(23, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1017, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleCancelActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(24)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1017, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void ScheduleCancelActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(24))
|
|
{
|
|
TD.WriteEtwEvent(24, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleCancelActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(24, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1014, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleCompletionWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(25)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1014, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
internal static void ScheduleCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(25))
|
|
{
|
|
TD.WriteEtwEvent(25, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(25, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1011, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleExecuteActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(26)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1011, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void ScheduleExecuteActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(26))
|
|
{
|
|
TD.WriteEtwEvent(26, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleExecuteActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(26, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1029, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleFaultWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(27)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1029, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void ScheduleFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(27))
|
|
{
|
|
TD.WriteEtwEvent(27, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(27, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1032, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleRuntimeWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(28)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1032, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void ScheduleRuntimeWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(28))
|
|
{
|
|
TD.WriteEtwEvent(28, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleRuntimeWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(28, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1026, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ScheduleTransactionContextWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(29)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1026, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void ScheduleTransactionContextWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(29))
|
|
{
|
|
TD.WriteEtwEvent(29, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ScheduleTransactionContextWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(29, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1022, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartBookmarkWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(30)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.
|
|
/// Event description ID=1022, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param3">Parameter 3 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
/// <param name="param4">Parameter 4 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
|
|
internal static void StartBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(30))
|
|
{
|
|
TD.WriteEtwEvent(30, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
|
|
TD.WriteTraceSource(30, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1018, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartCancelActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(31)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1018, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void StartCancelActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(31))
|
|
{
|
|
TD.WriteEtwEvent(31, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartCancelActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(31, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1015, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartCompletionWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(32)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1015, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
internal static void StartCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(32))
|
|
{
|
|
TD.WriteEtwEvent(32, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(32, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1012, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartExecuteActivityWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(33)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1012, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void StartExecuteActivityWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(33))
|
|
{
|
|
TD.WriteEtwEvent(33, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartExecuteActivityWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(33, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1030, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartFaultWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(34)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1030, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void StartFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(34))
|
|
{
|
|
TD.WriteEtwEvent(34, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(34, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1033, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartRuntimeWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(35)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1033, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void StartRuntimeWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(35))
|
|
{
|
|
TD.WriteEtwEvent(35, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartRuntimeWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(35, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1027, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool StartTransactionContextWorkItemIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(36)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
|
|
/// Event description ID=1027, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
|
|
internal static void StartTransactionContextWorkItem(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(36))
|
|
{
|
|
TD.WriteEtwEvent(36, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("StartTransactionContextWorkItem", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(36, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1025, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool BookmarkScopeInitializedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose
|
|
&& (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(37)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.
|
|
/// Event description ID=1025, Level=verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.</param>
|
|
internal static void BookmarkScopeInitialized(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(37))
|
|
{
|
|
TD.WriteEtwEvent(37, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceVerboseToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("BookmarkScopeInitialized", Culture), param0, param1);
|
|
TD.WriteTraceSource(37, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1104, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowActivityResumeIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(38)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
|
|
/// Event description ID=1104, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
|
|
internal static void WorkflowActivityResume(System.Guid Id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(38))
|
|
{
|
|
TD.WriteEtwEvent(38, null, Id, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityResume", Culture), Id);
|
|
TD.WriteTraceSource(38, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1101, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowActivityStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(39)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
|
|
/// Event description ID=1101, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
|
|
internal static void WorkflowActivityStart(System.Guid Id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(39))
|
|
{
|
|
TD.WriteEtwEvent(39, null, Id, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityStart", Culture), Id);
|
|
TD.WriteTraceSource(39, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1102, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowActivityStopIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(40)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
|
|
/// Event description ID=1102, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
|
|
internal static void WorkflowActivityStop(System.Guid Id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(40))
|
|
{
|
|
TD.WriteEtwEvent(40, null, Id, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityStop", Culture), Id);
|
|
TD.WriteTraceSource(40, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1103, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowActivitySuspendIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(41)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
|
|
/// Event description ID=1103, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
|
|
internal static void WorkflowActivitySuspend(System.Guid Id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(41))
|
|
{
|
|
TD.WriteEtwEvent(41, null, Id, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivitySuspend", Culture), Id);
|
|
TD.WriteTraceSource(41, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1010, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool ActivityCompletedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(42)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.
|
|
/// Event description ID=1010, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
|
|
/// <param name="param1">Parameter 1 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
|
|
/// <param name="param2">Parameter 2 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
|
|
/// <param name="param3">Parameter 3 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
|
|
internal static void ActivityCompleted(string param0, string param1, string param2, string param3)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(42))
|
|
{
|
|
TD.WriteEtwEvent(42, null, param0, param1, param2, param3, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ActivityCompleted", Culture), param0, param1, param2, param3);
|
|
TD.WriteTraceSource(42, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1009, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool ActivityScheduledIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(43)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
|
|
/// Event description ID=1009, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param3">Parameter 3 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param4">Parameter 4 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
/// <param name="param5">Parameter 5 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
|
|
internal static void ActivityScheduled(string param0, string param1, string param2, string param3, string param4, string param5)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(43))
|
|
{
|
|
TD.WriteEtwEvent(43, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("ActivityScheduled", Culture), param0, param1, param2, param3, param4, param5);
|
|
TD.WriteTraceSource(43, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1004, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowInstanceAbortedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(44)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' was aborted with an exception.
|
|
/// Event description ID=1004, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' was aborted with an exception.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void WorkflowInstanceAborted(string param0, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(44))
|
|
{
|
|
TD.WriteEtwEvent(44, null, param0, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowInstanceAborted", Culture), param0);
|
|
TD.WriteTraceSource(44, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1003, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowInstanceCanceledIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(45)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' has completed in the Canceled state.
|
|
/// Event description ID=1003, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has completed in the Canceled state.</param>
|
|
internal static void WorkflowInstanceCanceled(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(45))
|
|
{
|
|
TD.WriteEtwEvent(45, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowInstanceCanceled", Culture), param0);
|
|
TD.WriteTraceSource(45, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1001, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationCompletedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(46)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' has completed in the Closed state.
|
|
/// Event description ID=1001, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has completed in the Closed state.</param>
|
|
internal static void WorkflowApplicationCompleted(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(46))
|
|
{
|
|
TD.WriteEtwEvent(46, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationCompleted", Culture), param0);
|
|
TD.WriteTraceSource(46, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1005, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationIdledIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(47)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowApplication Id: '{0}' went idle.
|
|
/// Event description ID=1005, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' went idle.</param>
|
|
internal static void WorkflowApplicationIdled(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(47))
|
|
{
|
|
TD.WriteEtwEvent(47, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationIdled", Culture), param0);
|
|
TD.WriteTraceSource(47, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1041, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationPersistableIdleIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(48)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowApplication Id: '{0}' is idle and persistable. The following action will be taken: {1}.
|
|
/// Event description ID=1041, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' is idle and persistable. The following action will be taken: {1}.</param>
|
|
/// <param name="param1">Parameter 1 for event: WorkflowApplication Id: '{0}' is idle and persistable. The following action will be taken: {1}.</param>
|
|
internal static void WorkflowApplicationPersistableIdle(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(48))
|
|
{
|
|
TD.WriteEtwEvent(48, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationPersistableIdle", Culture), param0, param1);
|
|
TD.WriteTraceSource(48, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1007, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationPersistedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(49)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowApplication Id: '{0}' was Persisted.
|
|
/// Event description ID=1007, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' was Persisted.</param>
|
|
internal static void WorkflowApplicationPersisted(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(49))
|
|
{
|
|
TD.WriteEtwEvent(49, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationPersisted", Culture), param0);
|
|
TD.WriteTraceSource(49, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1002, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationTerminatedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(50)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowApplication Id: '{0}' was terminated. It has completed in the Faulted state with an exception.
|
|
/// Event description ID=1002, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' was terminated. It has completed in the Faulted state with an exception.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void WorkflowApplicationTerminated(string param0, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(50))
|
|
{
|
|
TD.WriteEtwEvent(50, null, param0, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationTerminated", Culture), param0);
|
|
TD.WriteTraceSource(50, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1006, Level=error, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationUnhandledExceptionIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceError
|
|
&& (FxTrace.ShouldTraceErrorToTraceSource || TD.IsEtwEventEnabled(51)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' has encountered an unhandled exception. The exception originated from Activity '{1}', DisplayName: '{2}'. The following action will be taken: {3}.
|
|
/// Event description ID=1006, Level=error, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception. The exception originated from Activity '{1}', DisplayName: '{2}'. The following action will be taken: {3}.</param>
|
|
/// <param name="param1">Parameter 1 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception. The exception originated from Activity '{1}', DisplayName: '{2}'. The following action will be taken: {3}.</param>
|
|
/// <param name="param2">Parameter 2 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception. The exception originated from Activity '{1}', DisplayName: '{2}'. The following action will be taken: {3}.</param>
|
|
/// <param name="param3">Parameter 3 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception. The exception originated from Activity '{1}', DisplayName: '{2}'. The following action will be taken: {3}.</param>
|
|
/// <param name="exception">Exception associated with the event</param>
|
|
internal static void WorkflowApplicationUnhandledException(string param0, string param1, string param2, string param3, System.Exception exception)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
|
|
if (TD.IsEtwEventEnabled(51))
|
|
{
|
|
TD.WriteEtwEvent(51, null, param0, param1, param2, param3, payload.SerializedException, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceErrorToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationUnhandledException", Culture), param0, param1, param2, param3);
|
|
TD.WriteTraceSource(51, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1008, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool WorkflowApplicationUnloadedIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(52)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: WorkflowInstance Id: '{0}' was Unloaded.
|
|
/// Event description ID=1008, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' was Unloaded.</param>
|
|
internal static void WorkflowApplicationUnloaded(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(52))
|
|
{
|
|
TD.WriteEtwEvent(52, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationUnloaded", Culture), param0);
|
|
TD.WriteTraceSource(52, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1124, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool InvokeMethodIsStaticIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(53)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InvokeMethod '{0}' - method is Static.
|
|
/// Event description ID=1124, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method is Static.</param>
|
|
internal static void InvokeMethodIsStatic(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(53))
|
|
{
|
|
TD.WriteEtwEvent(53, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodIsStatic", Culture), param0);
|
|
TD.WriteTraceSource(53, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1125, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool InvokeMethodIsNotStaticIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(54)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InvokeMethod '{0}' - method is not Static.
|
|
/// Event description ID=1125, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method is not Static.</param>
|
|
internal static void InvokeMethodIsNotStatic(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(54))
|
|
{
|
|
TD.WriteEtwEvent(54, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodIsNotStatic", Culture), param0);
|
|
TD.WriteTraceSource(54, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1126, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool InvokedMethodThrewExceptionIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(55)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: An exception was thrown in the method called by the activity '{0}'. {1}
|
|
/// Event description ID=1126, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: An exception was thrown in the method called by the activity '{0}'. {1}</param>
|
|
/// <param name="param1">Parameter 1 for event: An exception was thrown in the method called by the activity '{0}'. {1}</param>
|
|
internal static void InvokedMethodThrewException(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(55))
|
|
{
|
|
TD.WriteEtwEvent(55, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InvokedMethodThrewException", Culture), param0, param1);
|
|
TD.WriteTraceSource(55, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1131, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool InvokeMethodUseAsyncPatternIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(56)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.
|
|
/// Event description ID=1131, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
|
|
/// <param name="param1">Parameter 1 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
|
|
/// <param name="param2">Parameter 2 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
|
|
internal static void InvokeMethodUseAsyncPattern(string param0, string param1, string param2)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(56))
|
|
{
|
|
TD.WriteEtwEvent(56, null, param0, param1, param2, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodUseAsyncPattern", Culture), param0, param1, param2);
|
|
TD.WriteTraceSource(56, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1132, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool InvokeMethodDoesNotUseAsyncPatternIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(57)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InvokeMethod '{0}' - method does not use asynchronous pattern.
|
|
/// Event description ID=1132, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method does not use asynchronous pattern.</param>
|
|
internal static void InvokeMethodDoesNotUseAsyncPattern(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(57))
|
|
{
|
|
TD.WriteEtwEvent(57, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodDoesNotUseAsyncPattern", Culture), param0);
|
|
TD.WriteTraceSource(57, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1140, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(58)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}' - Start has been scheduled.
|
|
/// Event description ID=1140, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}' - Start has been scheduled.</param>
|
|
internal static void FlowchartStart(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(58))
|
|
{
|
|
TD.WriteEtwEvent(58, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartStart", Culture), param0);
|
|
TD.WriteTraceSource(58, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1141, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartEmptyIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning
|
|
&& (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(59)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}' - was executed with no Nodes.
|
|
/// Event description ID=1141, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}' - was executed with no Nodes.</param>
|
|
internal static void FlowchartEmpty(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(59))
|
|
{
|
|
TD.WriteEtwEvent(59, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceWarningToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartEmpty", Culture), param0);
|
|
TD.WriteTraceSource(59, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1143, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartNextNullIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(60)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}'/FlowStep - Next node is null. Flowchart execution will end.
|
|
/// Event description ID=1143, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowStep - Next node is null. Flowchart execution will end.</param>
|
|
internal static void FlowchartNextNull(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(60))
|
|
{
|
|
TD.WriteEtwEvent(60, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartNextNull", Culture), param0);
|
|
TD.WriteTraceSource(60, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1146, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartSwitchCaseIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(61)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.
|
|
/// Event description ID=1146, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.</param>
|
|
/// <param name="param1">Parameter 1 for event: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.</param>
|
|
internal static void FlowchartSwitchCase(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(61))
|
|
{
|
|
TD.WriteEtwEvent(61, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchCase", Culture), param0, param1);
|
|
TD.WriteTraceSource(61, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1147, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartSwitchDefaultIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(62)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}'/FlowSwitch - Default Case was selected.
|
|
/// Event description ID=1147, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - Default Case was selected.</param>
|
|
internal static void FlowchartSwitchDefault(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(62))
|
|
{
|
|
TD.WriteEtwEvent(62, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchDefault", Culture), param0);
|
|
TD.WriteTraceSource(62, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1148, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool FlowchartSwitchCaseNotFoundIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(63)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Flowchart '{0}'/FlowSwitch - could find neither a Case activity nor a Default Case matching the Expression result. Flowchart execution will end.
|
|
/// Event description ID=1148, Level=Informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - could find neither a Case activity nor a Default Case matching the Expression result. Flowchart execution will end.</param>
|
|
internal static void FlowchartSwitchCaseNotFound(string param0)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(63))
|
|
{
|
|
TD.WriteEtwEvent(63, null, param0, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchCaseNotFound", Culture), param0);
|
|
TD.WriteTraceSource(63, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=1150, Level=informational, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompensationStateIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceInformation
|
|
&& (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(64)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: CompensableActivity '{0}' is in the '{1}' state.
|
|
/// Event description ID=1150, Level=informational, Channel=debug
|
|
/// </summary>
|
|
/// <param name="param0">Parameter 0 for event: CompensableActivity '{0}' is in the '{1}' state.</param>
|
|
/// <param name="param1">Parameter 1 for event: CompensableActivity '{0}' is in the '{1}' state.</param>
|
|
internal static void CompensationState(string param0, string param1)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(64))
|
|
{
|
|
TD.WriteEtwEvent(64, null, param0, param1, payload.AppDomainFriendlyName);
|
|
}
|
|
if (FxTrace.ShouldTraceInformationToTraceSource)
|
|
{
|
|
string description = string.Format(Culture, ResourceManager.GetString("CompensationState", Culture), param0, param1);
|
|
TD.WriteTraceSource(64, description, payload);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=39460, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
internal static bool TrackingValueNotSerializableIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(65));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: The extracted argument/variable '{0}' is not serializable.
|
|
/// Event description ID=39460, Level=Warning, Channel=debug
|
|
/// </summary>
|
|
/// <param name="name">Parameter 0 for event: The extracted argument/variable '{0}' is not serializable.</param>
|
|
internal static void TrackingValueNotSerializable(string name)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(65))
|
|
{
|
|
TD.WriteEtwEvent(65, null, name, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2021, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ExecuteWorkItemStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(66));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Execute work item start
|
|
/// Event description ID=2021, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static void ExecuteWorkItemStart()
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(66))
|
|
{
|
|
TD.WriteEtwEvent(66, null, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2022, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool ExecuteWorkItemStopIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(67));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Execute work item stop
|
|
/// Event description ID=2022, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static void ExecuteWorkItemStop()
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(67))
|
|
{
|
|
TD.WriteEtwEvent(67, null, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2024, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool InternalCacheMetadataStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(68));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InternalCacheMetadata started on activity '{0}'.
|
|
/// Event description ID=2024, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="id">Parameter 0 for event: InternalCacheMetadata started on activity '{0}'.</param>
|
|
internal static void InternalCacheMetadataStart(string id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(68))
|
|
{
|
|
TD.WriteEtwEvent(68, null, id, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2025, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool InternalCacheMetadataStopIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(69));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: InternalCacheMetadata stopped on activity '{0}'.
|
|
/// Event description ID=2025, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="id">Parameter 0 for event: InternalCacheMetadata stopped on activity '{0}'.</param>
|
|
internal static void InternalCacheMetadataStop(string id)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(69))
|
|
{
|
|
TD.WriteEtwEvent(69, null, id, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2026, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompileVbExpressionStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(70));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Compiling VB expression '{0}'
|
|
/// Event description ID=2026, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="expr">Parameter 0 for event: Compiling VB expression '{0}'</param>
|
|
internal static void CompileVbExpressionStart(string expr)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(70))
|
|
{
|
|
TD.WriteEtwEvent(70, null, expr, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2029, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CompileVbExpressionStopIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(71));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: Finished compiling VB expression.
|
|
/// Event description ID=2029, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static void CompileVbExpressionStop()
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(71))
|
|
{
|
|
TD.WriteEtwEvent(71, null, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2027, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CacheRootMetadataStartIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(72));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: CacheRootMetadata started on activity '{0}'
|
|
/// Event description ID=2027, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="activityName">Parameter 0 for event: CacheRootMetadata started on activity '{0}'</param>
|
|
internal static void CacheRootMetadataStart(string activityName)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(72))
|
|
{
|
|
TD.WriteEtwEvent(72, null, activityName, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if trace definition is enabled
|
|
/// Event description ID=2028, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
internal static bool CacheRootMetadataStopIsEnabled()
|
|
{
|
|
return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(73));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets trace definition like: CacheRootMetadata stopped on activity {0}.
|
|
/// Event description ID=2028, Level=Verbose, Channel=debug
|
|
/// </summary>
|
|
/// <param name="activityName">Parameter 0 for event: CacheRootMetadata stopped on activity {0}.</param>
|
|
internal static void CacheRootMetadataStop(string activityName)
|
|
{
|
|
TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
|
|
if (TD.IsEtwEventEnabled(73))
|
|
{
|
|
TD.WriteEtwEvent(73, null, activityName, payload.AppDomainFriendlyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the event descriptors array
|
|
/// </summary>
|
|
// Critical = Sets the SecurityCritical member eventDescriptors
|
|
// Safe = We control what the event descriptors contain
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static void CreateEventDescriptors()
|
|
{
|
|
System.Runtime.Diagnostics.EventDescriptor[] descriptors = new System.Runtime.Diagnostics.EventDescriptor[] {
|
|
new System.Runtime.Diagnostics.EventDescriptor(39456, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)125, 0xa26, 0x1000000000000040),
|
|
new System.Runtime.Diagnostics.EventDescriptor(39457, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)126, 0xa26, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(39458, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)127, 0xa26, 0x1000000000000040),
|
|
new System.Runtime.Diagnostics.EventDescriptor(39459, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa25, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1223, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9e7, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2576, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)131, 0xa29, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2577, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)129, 0xa29, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2578, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)130, 0xa29, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1023, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)21, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1019, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)22, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1016, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)23, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1013, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)24, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1031, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)25, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1034, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)26, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1028, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)27, 0x9d6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1020, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9dc, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1024, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9dc, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1038, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9ff, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1039, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9ff, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1040, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9e7, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1037, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)104, 0xa08, 0x1000000004000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1036, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)105, 0xa08, 0x1000000004000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1035, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)106, 0xa08, 0x1000000004000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1021, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)107, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1017, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)108, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1014, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)109, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1011, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)110, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1029, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)111, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1032, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)112, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1026, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)113, 0xa0a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1022, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)117, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1018, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)118, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1015, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)119, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1012, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)120, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1030, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)121, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1033, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)122, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1027, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)123, 0xa1e, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1025, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9f5, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1104, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Resume, 0xa2f, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1101, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa2f, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1102, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa2f, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1103, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Suspend, 0xa2f, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1010, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9d5, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1009, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa09, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1004, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)136, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1003, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)137, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1001, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)134, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1005, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)135, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1041, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)138, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1007, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)139, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1002, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)140, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1006, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Error, (byte)141, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1008, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)142, 0xa2d, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1124, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)73, 0x9f7, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1125, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)72, 0x9f7, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1126, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)74, 0x9f7, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1131, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)75, 0x9f7, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1132, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)71, 0x9f7, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1140, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)11, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1141, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)60, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1143, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)61, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1146, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)62, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1147, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)64, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1148, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)63, 0x9e8, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(1150, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9d4, 0x1000000002000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(39460, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa25, 0x1000000000000040),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2021, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9e9, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2022, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9e9, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2024, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9f6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2025, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9f6, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2026, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa2a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2029, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa2a, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2027, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9ce, 0x1000000001000000),
|
|
new System.Runtime.Diagnostics.EventDescriptor(2028, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9ce, 0x1000000001000000)};
|
|
ushort[] e2eEvents = new ushort[0];
|
|
FxTrace.UpdateEventDefinitions(descriptors, e2eEvents);
|
|
eventDescriptors = descriptors;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ensures that the event descriptors array is initialized
|
|
/// </summary>
|
|
static void EnsureEventDescriptors()
|
|
{
|
|
if (eventDescriptorsCreated)
|
|
{
|
|
return;
|
|
}
|
|
System.Threading.Monitor.Enter(syncLock);
|
|
try
|
|
{
|
|
if (eventDescriptorsCreated)
|
|
{
|
|
return;
|
|
}
|
|
CreateEventDescriptors();
|
|
eventDescriptorsCreated = true;
|
|
}
|
|
finally
|
|
{
|
|
System.Threading.Monitor.Exit(syncLock);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if ETW tracing is enabled for the particular event
|
|
/// </summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>
|
|
static bool IsEtwEventEnabled(int eventIndex)
|
|
{
|
|
if (FxTrace.Trace.IsEtwProviderEnabled)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.IsEventEnabled(eventIndex);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, long eventParam1, System.Guid eventParam2, string eventParam3)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam4">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam5">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam6">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5, string eventParam6)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam4">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam4">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam5">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam6">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam7">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5, string eventParam6, string eventParam7)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6, eventParam7);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam4">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam5">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam6">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam7">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam8">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5, string eventParam6, string eventParam7, string eventParam8)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6, eventParam7, eventParam8);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, System.Guid eventParam1, string eventParam2)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes ETW trace event
|
|
///</summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>>
|
|
/// <param name="eventParam0">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam1">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam2">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam3">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam4">A parameter of the ETW event</param>>
|
|
/// <param name="eventParam5">A parameter of the ETW event</param>>
|
|
// Critical = Calls SecurityCritical method EtwProvider.WriteEvent
|
|
// Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5)
|
|
{
|
|
EnsureEventDescriptors();
|
|
return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5);
|
|
}
|
|
|
|
/// <summary>
|
|
/// write a trace source into the diagnostic trace
|
|
/// </summary>
|
|
/// <param name="eventIndex">The index of the event descriptor</param>
|
|
/// <param name="description">The description to write</param>
|
|
/// <param name="payload">The trace payload</param>
|
|
// Critical = Calls SecurityCritical method EtwDiagnosticTrace.WriteTraceSource
|
|
// Safe = We only allow setting of provider id from SecurityCritical code
|
|
[System.Security.SecuritySafeCriticalAttribute()]
|
|
static void WriteTraceSource(int eventIndex, string description, TracePayload payload)
|
|
{
|
|
EnsureEventDescriptors();
|
|
FxTrace.Trace.WriteTraceSource(ref eventDescriptors[eventIndex], description, payload);
|
|
}
|
|
}
|
|
}
|
|
|