File: Internals\WcfEventSource.cs
Web Access
Project: src\src\System.ServiceModel.Primitives\src\System.ServiceModel.Primitives.csproj (System.ServiceModel.Primitives)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Diagnostics.Tracing;
using System.Runtime.Diagnostics;
 
namespace System.Runtime
{
    [EventSource(Name = "Microsoft-Windows-Application Server-Applications", Guid = "c651f5f6-1c0d-492e-8ae1-b4efd7c9d503")]
    internal sealed class WcfEventSource : EventSource
    {
        // All events from NetFx can be found here:
        // https://github.com/dotnet/wcf/blob/6d515edfbdc2aa408d1ad1b40eb7f30f726039d2/src/System.Private.ServiceModel/src/Internals/WcfEventSource.cs
        // When adding more functionality which emits ETW events, this is the easiest place to get it from.
 
        public static WcfEventSource Instance = new WcfEventSource();
#pragma warning disable CS0414 // The field is assigned but its value is never used - Not used in Federation but is in S.P.SM
        private bool _canTransferActivityId = false;
#pragma warning restore CS0414 // The field is assigned but its value is never used
 
        internal WcfEventSource()
#if DEBUG
     : base(throwOnEventWriteErrors: true)
#endif // DEBUG
        {
            if (Environment.Version.Major >= 5)
            {
                _canTransferActivityId = true;
            }
        }
 
        public bool ActionItemScheduledIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Threading, EventChannel.Debug);
        }
 
        [Event(EventIds.ActionItemScheduled, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.ThreadScheduling, Keywords = Keywords.Threading | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "IO Thread scheduler callback invoked.")]
        public void ActionItemScheduled(string AppDomain)
        {
            WriteEvent(EventIds.ActionItemScheduled, AppDomain);
        }
 
        [NonEvent]
        public void ActionItemScheduled()
        {
            ActionItemScheduled("");
        }
 
        public bool ActionItemCallbackInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Threading, EventChannel.Debug);
        }
 
        [Event(EventIds.ActionItemCallbackInvoked, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.ThreadScheduling, Keywords = Keywords.Threading | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "IO Thread scheduler callback invoked.")]
        public void ActionItemCallbackInvoked(string AppDomain)
        {
            WriteEvent(EventIds.ActionItemCallbackInvoked, AppDomain);
        }
 
        [NonEvent]
        public void ActionItemCallbackInvoked()
        {
            ActionItemCallbackInvoked("");
        }
 
        public bool BufferPoolAllocationIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.BufferPoolAllocation, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = Opcodes.BufferPoolingAllocate, Task = Tasks.BufferPooling, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Pool allocating {0} Bytes.")]
        public void BufferPoolAllocation(int Size, string AppDomain)
        {
            WriteEvent(EventIds.BufferPoolAllocation, Size, AppDomain);
        }
 
        [NonEvent]
        public void BufferPoolAllocation(int Size)
        {
            BufferPoolAllocation(Size, "");
        }
 
        public bool BufferPoolChangeQuotaIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.BufferPoolChangeQuota, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = Opcodes.BufferPoolingTune, Task = Tasks.BufferPooling, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "BufferPool of size {0}, changing quota by {1}.")]
        public void BufferPoolChangeQuota(int PoolSize, int Delta, string AppDomain)
        {
            WriteEvent(EventIds.BufferPoolChangeQuota, PoolSize, Delta, AppDomain);
        }
 
        [NonEvent]
        public void BufferPoolChangeQuota(int PoolSize, int Delta)
        {
            BufferPoolChangeQuota(PoolSize, Delta, "");
        }
 
        public bool ClientMessageInspectorAfterReceiveInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientMessageInspectorAfterReceiveInvoked, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = Opcodes.ClientRuntimeClientMessageInspectorAfterReceiveInvoked, Task = Tasks.ClientRuntime, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Debug,
            Message = "The Dispatcher invoked 'AfterReceiveReply' on a ClientMessageInspector of type '{0}'.")]
        public void ClientMessageInspectorAfterReceiveInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ClientMessageInspectorAfterReceiveInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ClientMessageInspectorAfterReceiveInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ClientMessageInspectorAfterReceiveInvoked(TypeName, "", "");
        }
 
        public bool ClientMessageInspectorBeforeSendInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting
            | Keywords.ServiceModel
            , EventChannel.Analytic);
        }
 
        [Event(EventIds.ClientMessageInspectorBeforeSendInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.ClientRuntimeClientMessageInspectorBeforeSendInvoked, Task = Tasks.ClientRuntime, Keywords = Keywords.Troubleshooting
            | Keywords.ServiceModel
            | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked 'BeforeSendRequest' on a ClientMessageInspector of type  '{0}'.")]
        public void ClientMessageInspectorBeforeSendInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ClientMessageInspectorBeforeSendInvoked, TypeName, HostReference, AppDomain);
        }
 
 
        [NonEvent]
        public void ClientMessageInspectorBeforeSendInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ClientMessageInspectorBeforeSendInvoked(TypeName, "", "");
        }
 
        public bool ClientParameterInspectorAfterCallInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ClientParameterInspectorAfterCallInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.ClientRuntimeClientParameterInspectorStop, Task = Tasks.ClientRuntime, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked 'AfterCall' on a ClientParameterInspector of type '{0}'.")]
        public void ClientParameterInspectorAfterCallInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ClientParameterInspectorAfterCallInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ClientParameterInspectorAfterCallInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ClientParameterInspectorAfterCallInvoked(TypeName, "", "");
        }
 
        public bool ClientParameterInspectorBeforeCallInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ClientParameterInspectorBeforeCallInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.ClientRuntimeClientParameterInspectorStart, Task = Tasks.ClientRuntime, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked 'BeforeCall' on a ClientParameterInspector of type '{0}'.")]
        public void ClientParameterInspectorBeforeCallInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ClientParameterInspectorBeforeCallInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ClientParameterInspectorBeforeCallInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ClientParameterInspectorBeforeCallInvoked(TypeName, "", "");
        }
 
        public bool OperationInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.OperationInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageOperationInvokerStart, Task = Tasks.DispatchMessage, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "An OperationInvoker invoked the '{0}' method. Caller information: '{1}'.")]
        public void OperationInvoked(string MethodName, string CallerInfo, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.OperationInvoked, MethodName, CallerInfo, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void OperationInvoked(EventTraceActivity eventTraceActivity, string MethodName, string CallerInfo)
        {
            SetActivityId(eventTraceActivity);
            OperationInvoked(MethodName, CallerInfo, "", "");
        }
 
        public bool OutboundConnectionsPerEndpointRatioIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.OutboundConnectionsPerEndpointRatio, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "Outbound connections per endpoint ratio: {0}/{1}")]
        public void OutboundConnectionsPerEndpointRatio(int cur, int max, string AppDomain)
        {
            WriteEvent(EventIds.OutboundConnectionsPerEndpointRatio, cur, max, AppDomain);
        }
 
        [NonEvent]
        public void OutboundConnectionsPerEndpointRatio(int cur, int max)
        {
            OutboundConnectionsPerEndpointRatio(cur, max, "");
        }
 
        public bool ErrorHandlerInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ErrorHandlerInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked an ErrorHandler of type  '{0}' with an exception of type '{2}'.  ErrorHandled == '{1}'.")]
        public void ErrorHandlerInvoked(string TypeName, bool Handled, string ExceptionTypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ErrorHandlerInvoked, TypeName, Handled, ExceptionTypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ErrorHandlerInvoked(string TypeName, bool Handled, string ExceptionTypeName)
        {
            ErrorHandlerInvoked(TypeName, Handled, ExceptionTypeName, "", "");
        }
 
        public bool FaultProviderInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.FaultProviderInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked a FaultProvider of type '{0}' with an exception of type '{1}'.")]
        public void FaultProviderInvoked(string TypeName, string ExceptionTypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.FaultProviderInvoked, TypeName, ExceptionTypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void FaultProviderInvoked(string TypeName, string ExceptionTypeName)
        {
            FaultProviderInvoked(TypeName, ExceptionTypeName, "", "");
        }
 
        public bool MessageInspectorAfterReceiveInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageInspectorAfterReceiveInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageDispathMessageInspectorAfterReceiveInvoked, Task = Tasks.DispatchMessage,
            Keywords = Keywords.Troubleshooting | Keywords.ServiceModel,
            Message = "The Dispatcher invoked 'AfterReceiveReply' on a MessageInspector of type '{0}'.")]
        public void MessageInspectorAfterReceiveInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.MessageInspectorAfterReceiveInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void MessageInspectorAfterReceiveInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            MessageInspectorAfterReceiveInvoked(TypeName, "", "");
        }
 
        public bool MessageInspectorBeforeSendInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageInspectorBeforeSendInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageDispathMessageInspectorBeforeSendInvoked, Task = Tasks.DispatchMessage,
            Keywords = Keywords.Troubleshooting | Keywords.ServiceModel,
            Message = "The Dispatcher invoked 'BeforeSendRequest' on a MessageInspector of type '{0}'.")]
        public void MessageInspectorBeforeSendInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.MessageInspectorBeforeSendInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void MessageInspectorBeforeSendInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            MessageInspectorBeforeSendInvoked(TypeName, "", "");
        }
 
        public bool ParameterInspectorAfterCallInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ParameterInspectorAfterCallInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageParameterInspectorStop, Task = Tasks.DispatchMessage, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked 'AfterCall' on a ParameterInspector of type '{0}'.")]
        public void ParameterInspectorAfterCallInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ParameterInspectorAfterCallInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ParameterInspectorAfterCallInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ParameterInspectorAfterCallInvoked(TypeName, "", "");
        }
 
        public bool ParameterInspectorBeforeCallInvokedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ParameterInspectorBeforeCallInvoked, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageParameterInspectorStart, Task = Tasks.DispatchMessage, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The Dispatcher invoked 'BeforeCall' on a ParameterInspector of type '{0}'.")]
        public void ParameterInspectorBeforeCallInvoked(string TypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ParameterInspectorBeforeCallInvoked, TypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ParameterInspectorBeforeCallInvoked(EventTraceActivity eventTraceActivity, string TypeName)
        {
            SetActivityId(eventTraceActivity);
            ParameterInspectorBeforeCallInvoked(TypeName, "", "");
        }
 
        public bool OperationCompletedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.HealthMonitoring | Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.OperationCompleted, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageOperationInvokerStop, Task = Tasks.DispatchMessage, Keywords = Keywords.HealthMonitoring | Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "An OperationInvoker completed the call to the '{0}' method.  The method call duration was '{1}' ms.")]
        public void OperationCompleted(string MethodName, long Duration, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.OperationCompleted, MethodName, Duration, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void OperationCompleted(EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            SetActivityId(eventTraceActivity);
            OperationCompleted(MethodName, Duration, "", "");
        }
 
 
        public bool ClientOperationPreparedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientOperationPrepared, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = Opcodes.ClientRuntimeOperationPrepared, Task = Tasks.ClientRuntime, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Debug,
            Message = "The Client is executing Action '{0}' associated with the '{1}' contract. The message will be sent to '{2}'.")]
        public void ClientOperationPrepared(Guid relatedActivityId, string Action, string ContractName, string Destination, string HostReference, string AppDomain)
        {
            if (_canTransferActivityId)
            {
                WriteEventWithRelatedActivityId(EventIds.ClientOperationPrepared, relatedActivityId, Action, ContractName, Destination, HostReference, AppDomain);
            }
            else
            {
                WriteEvent(EventIds.ClientOperationPrepared, Action, ContractName, Destination, HostReference, AppDomain);
            }
        }
 
        [NonEvent]
        public void ClientOperationPrepared(EventTraceActivity eventTraceActivity, string Action, string ContractName, string Destination, Guid relatedActivityId)
        {
            TransferActivityId(eventTraceActivity);
            ClientOperationPrepared(relatedActivityId, Action, ContractName, Destination, "", "");
        }
 
        public bool ServiceChannelCallStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ServiceChannelCallStop, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Stop, Task = Tasks.ServiceChannelCall, Keywords = Keywords.Troubleshooting | Keywords.ServiceModel | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "The Client completed executing Action '{0}' associated with the '{1}' contract. The message was sent to '{2}'.")]
        public void ServiceChannelCallStop(string Action, string ContractName, string Destination, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ServiceChannelCallStop, Action, ContractName, Destination, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ServiceChannelCallStop(EventTraceActivity eventTraceActivity, string Action, string ContractName, string Destination)
        {
            SetActivityId(eventTraceActivity);
            ServiceChannelCallStop(Action, ContractName, Destination, "", "");
        }
 
        public bool ServiceExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ServiceException, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.DispatchMessage, Keywords = Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "There was an unhandled exception of type '{1}' during message processing.  Full Exception Details: {0}.")]
        public void ServiceException(string ExceptionToString, string ExceptionTypeName, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.ServiceException, ExceptionToString, ExceptionTypeName, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void ServiceException(string ExceptionToString, string ExceptionTypeName)
        {
            ServiceException(ExceptionToString, ExceptionTypeName, "", "");
        }
 
        public bool MessageSentByTransportIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.TransportGeneral, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageSentByTransport, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Stop, Task = Tasks.TransportSend, Keywords = Keywords.Troubleshooting | Keywords.TransportGeneral | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "The transport sent a message to '{0}'.")]
        public void MessageSentByTransport(string DestinationAddress, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.MessageSentByTransport, DestinationAddress, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void MessageSentByTransport(EventTraceActivity eventTraceActivity, string DestinationAddress)
        {
            SetActivityId(eventTraceActivity);
            MessageSentByTransport(DestinationAddress, "", "");
        }
 
        public bool MessageSentToTransportIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.TransportGeneral, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageSentToTransport, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.TransportGeneral | ChannelKeywords.Analytic,
            Message = "The Dispatcher sent a message to the transport. Correlation ID == '{0}'.")]
        public void MessageSentToTransport(Guid CorrelationId, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.MessageSentToTransport, CorrelationId, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void MessageSentToTransport(EventTraceActivity eventTraceActivity, Guid CorrelationId)
        {
            SetActivityId(eventTraceActivity);
            MessageSentToTransport(CorrelationId, "", "");
        }
 
        public bool MessageReceivedByTransportIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Troubleshooting | Keywords.TransportGeneral, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageReceivedByTransport, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Stop, Task = Tasks.TransportReceive, Keywords = Keywords.Troubleshooting | Keywords.TransportGeneral | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "The transport received a message from '{0}'.")]
        public void MessageReceivedByTransport(Guid relatedActivityId, string ListenAddress, string HostReference, string AppDomain)
        {
            if (_canTransferActivityId)
            {
                WriteEventWithRelatedActivityId(EventIds.MessageReceivedByTransport, relatedActivityId, ListenAddress, HostReference, AppDomain);
            }
            else
            {
                WriteEvent(EventIds.MessageReceivedByTransport, ListenAddress, HostReference, AppDomain);
            }
        }
 
        [NonEvent]
        public void MessageReceivedByTransport(EventTraceActivity eventTraceActivity, string ListenAddress, Guid relatedActivityId)
        {
            TransferActivityId(eventTraceActivity);
            MessageReceivedByTransport(relatedActivityId, ListenAddress, "", "");
        }
 
        public bool MessageReceivedFromTransportIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.TransportGeneral, EventChannel.Analytic);
        }
 
        [Event(EventIds.MessageReceivedFromTransport, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.TransportGeneral | ChannelKeywords.Analytic,
            Message = "The Dispatcher received a message from the transport. Correlation ID == '{0}'.")]
        public void MessageReceivedFromTransport(Guid CorrelationId, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.MessageReceivedFromTransport, CorrelationId, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void MessageReceivedFromTransport(EventTraceActivity eventTraceActivity, Guid CorrelationId, string HostReference)
        {
            SetActivityId(eventTraceActivity);
            MessageReceivedFromTransport(CorrelationId, HostReference, "");
        }
 
        public bool OperationFailedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.OperationFailed, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.DispatchMessage, Keywords = Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The '{0}' method threw an unhandled exception when invoked by the OperationInvoker. The method call duration was '{1}' ms.")]
        public void OperationFailed(string MethodName, long Duration, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.OperationFailed, MethodName, Duration, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void OperationFailed(EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            SetActivityId(eventTraceActivity);
            OperationFailed(MethodName, Duration, "", "");
        }
 
        public bool OperationFaultedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.OperationFaulted, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.DispatchMessage, Keywords = Keywords.EndToEndMonitoring | Keywords.Troubleshooting | Keywords.HealthMonitoring | Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "The '{0}' method threw a FaultException when invoked by the OperationInvoker. The method call duration was '{1}' ms.")]
        public void OperationFaulted(string MethodName, long Duration, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.OperationFaulted, MethodName, Duration, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void OperationFaulted(EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            SetActivityId(eventTraceActivity);
            OperationFaulted(MethodName, Duration, "", "");
        }
 
        public bool ServiceChannelOpenStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ServiceChannelOpenStart, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Start, Task = Tasks.ServiceChannelOpen, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "ServiceChannelOpen started.")]
        public void ServiceChannelOpenStart(string AppDomain)
        {
            WriteEvent(EventIds.ServiceChannelOpenStart, AppDomain);
        }
 
        [NonEvent]
        public void ServiceChannelOpenStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ServiceChannelOpenStart("");
        }
 
        public bool ServiceChannelOpenStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ServiceChannelOpenStop, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Stop, Task = Tasks.ServiceChannelOpen, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "ServiceChannelOpen completed.")]
        public void ServiceChannelOpenStop(string AppDomain)
        {
            WriteEvent(EventIds.ServiceChannelOpenStop, AppDomain);
        }
 
        [NonEvent]
        public void ServiceChannelOpenStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ServiceChannelOpenStop("");
        }
 
        public bool ServiceChannelCallStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ServiceChannelCallStart, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Start, Task = Tasks.ServiceChannelCall, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "ServiceChannelCall started.")]
        public void ServiceChannelCallStart(string AppDomain)
        {
            WriteEvent(EventIds.ServiceChannelCallStart, AppDomain);
        }
 
        [NonEvent]
        public void ServiceChannelCallStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ServiceChannelCallStart("");
        }
 
        [Event(EventIds.ServiceChannelBeginCallStart, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Start, Task = Tasks.ServiceChannelCall, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic, ActivityOptions = EventActivityOptions.Disable,
            Message = "ServiceChannel asynchronous calls started.")]
        public void ServiceChannelBeginCallStart(string AppDomain)
        {
            WriteEvent(EventIds.ServiceChannelBeginCallStart, AppDomain);
        }
 
        [NonEvent]
        public void ServiceChannelBeginCallStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ServiceChannelBeginCallStart("");
        }
 
        public bool DispatchMessageStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.DispatchMessageStart, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageDispatchStart, Task = Tasks.DispatchMessage, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "Message dispatching started.")]
        public void DispatchMessageStart(string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.DispatchMessageStart, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void DispatchMessageStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchMessageStart("", "");
        }
 
        public bool DispatchMessageStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.DispatchMessageStop, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.DispatchMessageDispatchStop, Task = Tasks.DispatchMessage, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "Message dispatching completed")]
        public void DispatchMessageStop(string AppDomain)
        {
            WriteEvent(EventIds.DispatchMessageStop, AppDomain);
        }
 
        [NonEvent]
        public void DispatchMessageStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchMessageStop("");
        }
 
        public bool ClientChannelOpenStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ClientChannelOpenStart, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.ClientRuntimeClientChannelOpenStart, Task = Tasks.ClientRuntime, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "ServiceChannel Open Start.")]
        public void ClientChannelOpenStart(string AppDomain)
        {
            WriteEvent(EventIds.ClientChannelOpenStart, AppDomain);
        }
 
        [NonEvent]
        public void ClientChannelOpenStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientChannelOpenStart("");
        }
 
        public bool ClientChannelOpenStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ClientChannelOpenStop, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = Opcodes.ClientRuntimeClientChannelOpenStop, Task = Tasks.ClientRuntime, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "ServiceChannel Open Stop.")]
        public void ClientChannelOpenStop(string AppDomain)
        {
            WriteEvent(EventIds.ClientChannelOpenStop, AppDomain);
        }
 
        [NonEvent]
        public void ClientChannelOpenStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientChannelOpenStop("");
        }
 
        [Event(EventIds.ScheduleRuntimeWorkItem, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = Opcodes.ScheduleWorkItemScheduleRuntime, Task = Tasks.ScheduleWorkItem, Keywords = Keywords.WFRuntime | ChannelKeywords.Debug,
            Message = "A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.")]
        public void ScheduleRuntimeWorkItem(string data1, string data2, string data3, string AppDomain)
        {
            WriteEvent(EventIds.ScheduleRuntimeWorkItem, data1, data2, data3, AppDomain);
        }
 
        public bool IdleTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.IdleTimeout, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.TimeoutException, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "{0} Connection pool key: {1}")]
        public void IdleTimeout(string msg, string key, string AppDomain)
        {
            WriteEvent(EventIds.IdleTimeout, msg, key, AppDomain);
        }
 
        [NonEvent]
        public void IdleTimeout(string msg, string key)
        {
            IdleTimeout(msg, key, "");
        }
 
        public bool InactivityTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.InactivityTimeout, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.TimeoutException, Keywords = Keywords.ServiceModel,
            Message = "{0}")]
        public void InactivityTimeout(string data1, string AppDomain)
        {
            WriteEvent(EventIds.InactivityTimeout, data1, AppDomain);
        }
 
        [NonEvent]
        public void InactivityTimeout(string data1)
        {
            InactivityTimeout(data1, "");
        }
 
        public bool MaxOutboundConnectionsPerEndpointExceededIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Quota, EventChannel.Debug);
        }
 
        [Event(EventIds.MaxOutboundConnectionsPerEndpointExceeded, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Debug,
            Message = "{0}")]
        public void MaxOutboundConnectionsPerEndpointExceeded(string data1, string AppDomain)
        {
            WriteEvent(EventIds.MaxOutboundConnectionsPerEndpointExceeded, data1, AppDomain);
        }
 
        [NonEvent]
        public void MaxOutboundConnectionsPerEndpointExceeded(string data1)
        {
            MaxOutboundConnectionsPerEndpointExceeded(data1, "");
        }
 
        public bool MaxReceivedMessageSizeExceededIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.MaxReceivedMessageSizeExceeded, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "{0}")]
        public void MaxReceivedMessageSizeExceeded(string data1, string AppDomain)
        {
            WriteEvent(EventIds.MaxReceivedMessageSizeExceeded, data1, AppDomain);
        }
 
        [NonEvent]
        public void MaxReceivedMessageSizeExceeded(string data1)
        {
            MaxReceivedMessageSizeExceeded(data1, "");
        }
 
        public bool MaxRetryCyclesExceededIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.MaxRetryCyclesExceeded, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota,
            Message = "{0}")]
        public void MaxRetryCyclesExceeded(string data1)
        {
            WriteEvent(EventIds.MaxRetryCyclesExceeded, data1);
        }
 
        public bool MaxSentMessageSizeExceededIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.MaxSentMessageSizeExceeded, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "{0}")]
        public void MaxSentMessageSizeExceeded(string data1, string AppDomain)
        {
            WriteEvent(EventIds.MaxSentMessageSizeExceeded, data1, AppDomain);
        }
 
        [NonEvent]
        public void MaxSentMessageSizeExceeded(string data1)
        {
            MaxSentMessageSizeExceeded(data1, "");
        }
 
        public bool MaxSessionSizeReachedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.MaxSessionSizeReached, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "{0}")]
        public void MaxSessionSizeReached(string data1, string AppDomain)
        {
            WriteEvent(EventIds.MaxSessionSizeReached, data1, AppDomain);
        }
 
        [NonEvent]
        public void MaxSessionSizeReached(string data1)
        {
            MaxSessionSizeReached(data1, "");
        }
 
        public bool ReadPoolMissIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.ReadPoolMiss, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "Created new '{0}'")]
        public void ReadPoolMiss(string itemTypeName, string AppDomain)
        {
            WriteEvent(EventIds.ReadPoolMiss, itemTypeName, AppDomain);
        }
 
        [NonEvent]
        public void ReadPoolMiss(string itemTypeName)
        {
            ReadPoolMiss(itemTypeName, "");
        }
 
        public bool WritePoolMissIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Quota, EventChannel.Analytic);
        }
 
        [Event(EventIds.WritePoolMiss, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Quotas, Keywords = Keywords.Quota | ChannelKeywords.Analytic,
            Message = "Created new '{0}'")]
        public void WritePoolMiss(string itemTypeName, string AppDomain)
        {
            WriteEvent(EventIds.WritePoolMiss, itemTypeName, AppDomain);
        }
 
        [NonEvent]
        public void WritePoolMiss(string itemTypeName)
        {
            WritePoolMiss(itemTypeName, "");
        }
 
        public bool ClientBaseCachedChannelFactoryCountIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientBaseCachedChannelFactoryCount, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ChannelFactoryCaching,
            Keywords = Keywords.ServiceModel,
            Message = "Number of cached channel factories is: '{0}'.  At most '{1}' channel factories can be cached.")]
        public void ClientBaseCachedChannelFactoryCount(int Count, int MaxNum, string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.ClientBaseCachedChannelFactoryCount, Count, MaxNum, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void ClientBaseCachedChannelFactoryCount(int Count, int MaxNum, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            ClientBaseCachedChannelFactoryCount(Count, MaxNum, payload.EventSource, "");
        }
 
        public bool ClientBaseChannelFactoryAgedOutofCacheIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientBaseChannelFactoryAgedOutofCache, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ChannelFactoryCaching,
            Keywords = Keywords.ServiceModel,
            Message = "A channel factory has been aged out of the cache because the cache has reached its limit of '{0}'.")]
        public void ClientBaseChannelFactoryAgedOutofCache(int Count, string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.ClientBaseChannelFactoryAgedOutofCache, Count, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void ClientBaseChannelFactoryAgedOutofCache(int Count, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            ClientBaseChannelFactoryAgedOutofCache(Count, payload.EventSource, "");
        }
 
        public bool ClientBaseChannelFactoryCacheHitIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientBaseChannelFactoryCacheHit, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ChannelFactoryCaching,
            Keywords = Keywords.ServiceModel,
            Message = "Used matching channel factory found in cache.")]
        public void ClientBaseChannelFactoryCacheHit(string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.ClientBaseChannelFactoryCacheHit, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void ClientBaseChannelFactoryCacheHit(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            ClientBaseChannelFactoryCacheHit(payload.EventSource, "");
        }
 
        public bool ClientBaseUsingLocalChannelFactoryIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientBaseUsingLocalChannelFactory, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ChannelFactoryCaching,
            Keywords = Keywords.ServiceModel,
            Message = "Not using channel factory from cache, i.e. caching disabled for instance.")]
        public void ClientBaseUsingLocalChannelFactory(string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.ClientBaseUsingLocalChannelFactory, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void ClientBaseUsingLocalChannelFactory(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            ClientBaseUsingLocalChannelFactory(payload.EventSource, "");
        }
 
        public bool MessageReadByEncoderIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.MessageReadByEncoder, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.MessageDecoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "A message with size '{0}' bytes was read by the encoder.")]
        public void MessageReadByEncoder(int Size, string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.MessageReadByEncoder, Size, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void MessageReadByEncoder(EventTraceActivity eventTraceActivity, int Size, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            SetActivityId(eventTraceActivity);
            MessageReadByEncoder(Size, payload.EventSource, "");
        }
 
        public bool MessageWrittenByEncoderIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.MessageWrittenByEncoder, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.MessageEncoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "A message with size '{0}' bytes was written by the encoder.")]
        public void MessageWrittenByEncoder(int Size, string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.MessageWrittenByEncoder, Size, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void MessageWrittenByEncoder(EventTraceActivity eventTraceActivity, int Size, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            SetActivityId(eventTraceActivity);
            MessageWrittenByEncoder(Size, payload.EventSource, "");
        }
 
        public bool SessionIdleTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.SessionIdleTimeout, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Timeout, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "Session aborting for idle channel to uri:'{0}'.")]
        public void SessionIdleTimeout(string RemoteAddress, string AppDomain)
        {
            WriteEvent(EventIds.SessionIdleTimeout, RemoteAddress, AppDomain);
        }
 
        [NonEvent]
        public void SessionIdleTimeout(string RemoteAddress)
        {
            SessionIdleTimeout(RemoteAddress, "");
        }
 
        public bool SocketReadStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.TCP, EventChannel.Debug);
        }
 
        [Event(EventIds.SocketReadStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.TransportReceive, Keywords = Keywords.TCP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "SocketId:{0} read '{1}' bytes read from '{2}'.")]
        public void SocketReadStop(int SocketId, int Size, string Endpoint, string AppDomain)
        {
            WriteEvent(EventIds.SocketReadStop, SocketId, Size, Endpoint, AppDomain);
        }
 
        [NonEvent]
        public void SocketReadStop(int SocketId, int Size, string Endpoint)
        {
            SocketReadStop(SocketId, Size, Endpoint, "");
        }
 
        public bool SocketAsyncReadStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.TCP, EventChannel.Debug);
        }
        [Event(EventIds.SocketAsyncReadStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.TransportReceive, Keywords = Keywords.TCP | ChannelKeywords.Debug,
            Message = "SocketId:{0} read '{1}' bytes read from '{2}'.")]
        public void SocketAsyncReadStop(int SocketId, int Size, string Endpoint, string AppDomain)
        {
            WriteEvent(EventIds.SocketAsyncReadStop, SocketId, Size, Endpoint, AppDomain);
        }
 
        [NonEvent]
        public void SocketAsyncReadStop(int SocketId, int Size, string Endpoint)
        {
            SocketAsyncReadStop(SocketId, Size, Endpoint, "");
        }
 
        public bool SocketWriteStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.TCP, EventChannel.Debug);
        }
        [Event(EventIds.SocketWriteStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.TransportSend, Keywords = Keywords.TCP | ChannelKeywords.Debug,
            Message = "SocketId:{0} writing '{1}' bytes to '{2}'.")]
        public void SocketWriteStart(int SocketId, int Size, string Endpoint, string AppDomain)
        {
            WriteEvent(EventIds.SocketWriteStart, SocketId, Size, Endpoint, AppDomain);
        }
 
        [NonEvent]
        public void SocketWriteStart(int SocketId, int Size, string Endpoint)
        {
            SocketWriteStart(SocketId, Size, Endpoint, "");
        }
 
        public bool SocketAsyncWriteStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.TCP, EventChannel.Debug);
        }
        [Event(EventIds.SocketAsyncWriteStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.TransportSend, Keywords = Keywords.TCP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "SocketId:{0} writing '{1}' bytes to '{2}'.")]
        public void SocketAsyncWriteStart(int SocketId, int Size, string Endpoint, string AppDomain)
        {
            WriteEvent(EventIds.SocketAsyncWriteStart, SocketId, Size, Endpoint, AppDomain);
        }
 
        [NonEvent]
        public void SocketAsyncWriteStart(int SocketId, int Size, string Endpoint)
        {
            SocketAsyncWriteStart(SocketId, Size, Endpoint, "");
        }
 
        public bool SslOnInitiateUpgradeIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Analytic);
        }
 
        [Event(EventIds.SslOnInitiateUpgrade, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = Opcodes.SessionUpgradeInitiate, Task = Tasks.SessionUpgrade, Keywords = Keywords.Security | ChannelKeywords.Analytic,
            Message = "SslOnAcceptUpgradeStart")]
        public void SslOnInitiateUpgrade(string AppDomain)
        {
            WriteEvent(EventIds.SslOnInitiateUpgrade, AppDomain);
        }
 
        [NonEvent]
        public void SslOnInitiateUpgrade()
        {
            SslOnInitiateUpgrade("");
        }
 
        public bool DispatchFormatterDeserializeRequestStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.DispatchFormatterDeserializeRequestStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.FormatterDeserializeRequest, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Dispatcher started deserialization the request message.")]
        public void DispatchFormatterDeserializeRequestStart(string AppDomain)
        {
            WriteEvent(EventIds.DispatchFormatterDeserializeRequestStart, AppDomain);
        }
 
        [NonEvent]
        public void DispatchFormatterDeserializeRequestStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchFormatterDeserializeRequestStart("");
        }
 
        public bool DispatchFormatterDeserializeRequestStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.DispatchFormatterDeserializeRequestStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.FormatterDeserializeRequest, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Dispatcher completed deserialization the request message.")]
        public void DispatchFormatterDeserializeRequestStop(string AppDomain)
        {
            WriteEvent(EventIds.DispatchFormatterDeserializeRequestStop, AppDomain);
        }
 
        [NonEvent]
        public void DispatchFormatterDeserializeRequestStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchFormatterDeserializeRequestStop("");
        }
 
        public bool DispatchFormatterSerializeReplyStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.DispatchFormatterSerializeReplyStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.FormatterSerializeReply, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Dispatcher started serialization of the reply message.")]
        public void DispatchFormatterSerializeReplyStart(string AppDomain)
        {
            WriteEvent(EventIds.DispatchFormatterSerializeReplyStart, AppDomain);
        }
 
        [NonEvent]
        public void DispatchFormatterSerializeReplyStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchFormatterSerializeReplyStart("");
        }
 
        public bool DispatchFormatterSerializeReplyStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.DispatchFormatterSerializeReplyStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.FormatterSerializeReply, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Dispatcher completed serialization of the reply message.")]
        public void DispatchFormatterSerializeReplyStop(string AppDomain)
        {
            WriteEvent(EventIds.DispatchFormatterSerializeReplyStop, AppDomain);
        }
 
        [NonEvent]
        public void DispatchFormatterSerializeReplyStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            DispatchFormatterSerializeReplyStop("");
        }
 
        public bool ClientFormatterSerializeRequestStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientFormatterSerializeRequestStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.FormatterSerializeRequest, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Client request serialization started.")]
        public void ClientFormatterSerializeRequestStart(string AppDomain)
        {
            WriteEvent(EventIds.ClientFormatterSerializeRequestStart, AppDomain);
        }
 
        [NonEvent]
        public void ClientFormatterSerializeRequestStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientFormatterSerializeRequestStart("");
        }
 
        public bool ClientFormatterSerializeRequestStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientFormatterSerializeRequestStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.FormatterSerializeRequest, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Client completed serialization of the request message.")]
        public void ClientFormatterSerializeRequestStop(string AppDomain)
        {
            WriteEvent(EventIds.ClientFormatterSerializeRequestStop, AppDomain);
        }
 
        [NonEvent]
        public void ClientFormatterSerializeRequestStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientFormatterSerializeRequestStop("");
        }
 
        public bool ClientFormatterDeserializeReplyStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientFormatterDeserializeReplyStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.FormatterDeserializeReply, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Client started deserializing the reply message.")]
        public void ClientFormatterDeserializeReplyStart(string AppDomain)
        {
            WriteEvent(EventIds.ClientFormatterDeserializeReplyStart, AppDomain);
        }
 
        [NonEvent]
        public void ClientFormatterDeserializeReplyStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientFormatterDeserializeReplyStart("");
        }
 
        public bool ClientFormatterDeserializeReplyStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientFormatterDeserializeReplyStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.FormatterDeserializeReply, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Client completed deserializing the reply message.")]
        public void ClientFormatterDeserializeReplyStop(string AppDomain)
        {
            WriteEvent(EventIds.ClientFormatterDeserializeReplyStop, AppDomain);
        }
 
        [NonEvent]
        public void ClientFormatterDeserializeReplyStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ClientFormatterDeserializeReplyStop("");
        }
 
        public bool GetServiceInstanceStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.GetServiceInstanceStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.ServiceInstance, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Service instance retrieval started.")]
        public void GetServiceInstanceStart(string AppDomain)
        {
            WriteEvent(EventIds.GetServiceInstanceStart, AppDomain);
        }
 
        [NonEvent]
        public void GetServiceInstanceStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            GetServiceInstanceStart("");
        }
 
        public bool GetServiceInstanceStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.GetServiceInstanceStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.ServiceInstance, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Service instance retrieved.")]
        public void GetServiceInstanceStop(string AppDomain)
        {
            WriteEvent(EventIds.GetServiceInstanceStop, AppDomain);
        }
 
        [NonEvent]
        public void GetServiceInstanceStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            GetServiceInstanceStop("");
        }
 
 
        public bool HandledExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.HandledException, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Handling an exception.  Exception details: {0}")]
        public void HandledException(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.HandledException, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void HandledException(string data1, string SerializedException)
        {
            HandledException(data1, SerializedException, "");
        }
 
        public bool HandledExceptionErrorIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Infrastructure, EventChannel.Operational);
        }
 
        [Event(EventIds.HandledExceptionError, Level = EventLevel.Error, Channel = EventChannel.Operational, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Operational,
            Message = "Handling an exception. Exception details: {0}")]
        public void HandledExceptionError(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.HandledExceptionError, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void HandledExceptionError(string data1, string SerializedException)
        {
            HandledExceptionError(data1, SerializedException, "");
        }
 
        public bool HandledExceptionVerboseIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.HandledExceptionVerbose, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Handling an exception  Exception details: {0}")]
        public void HandledExceptionVerbose(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.HandledExceptionVerbose, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void HandledExceptionVerbose(string data1, string SerializedException)
        {
            HandledExceptionVerbose(data1, SerializedException, "");
        }
 
        public bool HandledExceptionWarningIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.HandledExceptionWarning, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Handling an exception. Exception details: {0}")]
        public void HandledExceptionWarning(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.HandledExceptionWarning, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void HandledExceptionWarning(string data1, string SerializedException)
        {
            HandledExceptionWarning(data1, SerializedException, "");
        }
 
        public bool ThrowingEtwExceptionVerboseIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.ThrowingEtwExceptionVerbose, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Throwing an exception. Source: {0}. Exception details: {1}")]
        public void ThrowingEtwExceptionVerbose(string data1, string data2, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.ThrowingEtwExceptionVerbose, data1, data2, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void ThrowingEtwExceptionVerbose(string data1, string data2, string SerializedException)
        {
            ThrowingEtwExceptionVerbose(data1, data2, SerializedException, "");
        }
 
        [NonEvent]
        public void ThrowingEtwExceptionVerbose(string data1, string data2, Exception exception)
        {
            TracePayload serializedPayload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            ThrowingEtwExceptionVerbose(data1, data2, serializedPayload.SerializedException, "");
        }
 
        public bool ChannelReceiveStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ChannelReceiveStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.ChannelReceive, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "ChannelHandlerId:{0} - Message receive loop started.")]
        public void ChannelReceiveStart(int ChannelId, string AppDomain)
        {
            WriteEvent(EventIds.ChannelReceiveStart, ChannelId, AppDomain);
        }
 
        [NonEvent]
        public void ChannelReceiveStart(EventTraceActivity eventTraceActivity, int ChannelId)
        {
            SetActivityId(eventTraceActivity);
            ChannelReceiveStart(ChannelId, "");
        }
 
        public bool ChannelReceiveStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ChannelReceiveStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.ChannelReceive, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "ChannelHandlerId:{0} - Message receive loop stopped.")]
        public void ChannelReceiveStop(int ChannelId, string AppDomain)
        {
            WriteEvent(EventIds.ChannelReceiveStop, ChannelId, AppDomain);
        }
 
        [NonEvent]
        public void ChannelReceiveStop(EventTraceActivity eventTraceActivity, int ChannelId)
        {
            SetActivityId(eventTraceActivity);
            ChannelReceiveStop(ChannelId, "");
        }
 
        public bool ChannelFactoryCreatedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.ServiceModel, EventChannel.Debug);
        }
 
        [Event(EventIds.ChannelFactoryCreated, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ChannelFactoryCreate, Keywords = Keywords.ServiceModel | ChannelKeywords.Debug,
            Message = "ChannelFactory created .")]
        public void ChannelFactoryCreated(string EventSource, string AppDomain)
        {
            WriteEvent(EventIds.ChannelFactoryCreated, EventSource, AppDomain);
        }
 
        [NonEvent]
        public void ChannelFactoryCreated(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            ChannelFactoryCreated(payload.EventSource, "");
        }
 
        public bool LeaseTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.LeaseTimeout, Level = EventLevel.Informational, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.TimeoutException, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "{0} Connection pool key: {1}")]
        public void LeaseTimeout(string msg, string key, string AppDomain)
        {
            WriteEvent(EventIds.LeaseTimeout, msg, key, AppDomain);
        }
 
        [NonEvent]
        public void LeaseTimeout(string msg, string key)
        {
            LeaseTimeout(msg, key, "");
        }
 
        public bool ListenerOpenStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ListenerOpenStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.ListenerOpen, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Listener opening for '{0}'.")]
        public void ListenerOpenStart(string Uri, string AppDomain)
        {
            WriteEvent(EventIds.ListenerOpenStart, Uri, AppDomain);
        }
 
        [NonEvent]
        public void ListenerOpenStart(EventTraceActivity eventTraceActivity, string Uri, Guid relatedActivityId)
        {
            TransferActivityId(eventTraceActivity);
            ListenerOpenStart(Uri, "");
        }
 
        public bool ListenerOpenStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ListenerOpenStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.ListenerOpen, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "Listener open completed.")]
        public void ListenerOpenStop(string AppDomain)
        {
            WriteEvent(EventIds.ListenerOpenStop, AppDomain);
        }
 
        [NonEvent]
        public void ListenerOpenStop(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            ListenerOpenStop("");
        }
 
        public bool SecurityIdentityVerificationFailureIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Security, EventChannel.Analytic);
        }
 
        [Event(EventIds.SecurityIdentityVerificationFailure, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.SecurityVerification, Keywords = Keywords.Security | ChannelKeywords.Analytic,
            Message = "Security verification failed.")]
        public void SecurityIdentityVerificationFailure(string AppDomain)
        {
            WriteEvent(EventIds.SecurityIdentityVerificationFailure, AppDomain);
        }
 
        [NonEvent]
        public void SecurityIdentityVerificationFailure(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            SecurityIdentityVerificationFailure("");
        }
 
        public bool SecurityIdentityVerificationSuccessIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Debug);
        }
 
        [Event(EventIds.SecurityIdentityVerificationSuccess, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.SecurityVerification,
            Keywords = Keywords.Security,
            Message = "Security verification succeeded.")]
        public void SecurityIdentityVerificationSuccess(string AppDomain)
        {
            WriteEvent(EventIds.SecurityIdentityVerificationSuccess, AppDomain);
        }
 
        [NonEvent]
        public void SecurityIdentityVerificationSuccess(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            SecurityIdentityVerificationSuccess("");
        }
 
        public bool SecurityTokenProviderOpenedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Debug);
        }
 
        [Event(EventIds.SecurityTokenProviderOpened, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.SecureMessage,
            Keywords = Keywords.Security, Message = "SecurityTokenProvider opening completed.")]
        public void SecurityTokenProviderOpened(string AppDomain)
        {
            WriteEvent(EventIds.SecurityTokenProviderOpened, AppDomain);
        }
 
        [NonEvent]
        public void SecurityTokenProviderOpened(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            SecurityTokenProviderOpened("");
        }
 
        public bool BinaryMessageEncodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.BinaryMessageEncodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageEncoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "BinaryMessageEncoder started encoding the message.")]
        public void BinaryMessageEncodingStart(string AppDomain)
        {
            WriteEvent(EventIds.BinaryMessageEncodingStart, AppDomain);
        }
 
        [NonEvent]
        public void BinaryMessageEncodingStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            BinaryMessageEncodingStart("");
        }
 
        public bool MtomMessageEncodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.MtomMessageEncodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageEncoding,
            Keywords = Keywords.Channel,
            Message = "MtomMessageEncoder started encoding the message.")]
        public void MtomMessageEncodingStart(string AppDomain)
        {
            WriteEvent(EventIds.MtomMessageEncodingStart, AppDomain);
        }
 
        [NonEvent]
        public void MtomMessageEncodingStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            MtomMessageEncodingStart("");
        }
 
        public bool TextMessageEncodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.TextMessageEncodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageEncoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "TextMessageEncoder started encoding the message.")]
        public void TextMessageEncodingStart(string AppDomain)
        {
            WriteEvent(EventIds.TextMessageEncodingStart, AppDomain);
        }
 
        [NonEvent]
        public void TextMessageEncodingStart(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            TextMessageEncodingStart("");
        }
 
        public bool BinaryMessageDecodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.BinaryMessageDecodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageDecoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "BinaryMessageEncoder started decoding the message.")]
        public void BinaryMessageDecodingStart(string AppDomain)
        {
            WriteEvent(EventIds.BinaryMessageDecodingStart, AppDomain);
        }
 
        [NonEvent]
        public void BinaryMessageDecodingStart()
        {
            BinaryMessageDecodingStart("");
        }
 
        public bool MtomMessageDecodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.MtomMessageDecodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageDecoding,
            Keywords = Keywords.Channel,
            Message = "MtomMessageEncoder started decoding the message.")]
        public void MtomMessageDecodingStart(string AppDomain)
        {
            WriteEvent(EventIds.MtomMessageDecodingStart, AppDomain);
        }
 
        [NonEvent]
        public void MtomMessageDecodingStart()
        {
            MtomMessageDecodingStart("");
        }
 
        public bool TextMessageDecodingStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.TextMessageDecodingStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.MessageDecoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "TextMessageEncoder started decoding the message.")]
        public void TextMessageDecodingStart(string AppDomain)
        {
            WriteEvent(EventIds.TextMessageDecodingStart, AppDomain);
        }
 
        [NonEvent]
        public void TextMessageDecodingStart()
        {
            TextMessageDecodingStart("");
        }
 
        public bool SequenceAcknowledgementSentIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.SequenceAcknowledgementSent, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = Opcodes.ReliableSessionSequenceAck, Task = Tasks.ReliableSession, Keywords = Keywords.Channel,
            Message = "SessionId:{0} acknowledgement sent.")]
        public void SequenceAcknowledgementSent(string SessionId, string AppDomain)
        {
            WriteEvent(EventIds.SequenceAcknowledgementSent, SessionId, AppDomain);
        }
 
        [NonEvent]
        public void SequenceAcknowledgementSent(string SessionId)
        {
            SequenceAcknowledgementSent(SessionId, "");
        }
 
        public bool ClientReliableSessionReconnectIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ClientReliableSessionReconnect, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = Opcodes.ReliableSessionReconnect, Task = Tasks.ReliableSession, Keywords = Keywords.Channel,
            Message = "SessionId:{0} reconnecting.")]
        public void ClientReliableSessionReconnect(string SessionId, string AppDomain)
        {
            WriteEvent(EventIds.ClientReliableSessionReconnect, SessionId, AppDomain);
        }
 
        [NonEvent]
        public void ClientReliableSessionReconnect(string SessionId)
        {
            ClientReliableSessionReconnect(SessionId, "");
        }
 
        public bool CloseTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.CloseTimeout, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.TimeoutException, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "{0}")]
        public void CloseTimeout(string data1, string AppDomain)
        {
            WriteEvent(EventIds.CloseTimeout, data1, AppDomain);
        }
 
        [NonEvent]
        public void CloseTimeout(string data1)
        {
            CloseTimeout(data1, "");
        }
 
        public bool ReceiveTimeoutIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.ServiceModel, EventChannel.Analytic);
        }
 
        [Event(EventIds.ReceiveTimeout, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.TimeoutException, Keywords = Keywords.ServiceModel | ChannelKeywords.Analytic,
            Message = "{0}")]
        public void ReceiveTimeout(string data1, string AppDomain)
        {
            WriteEvent(EventIds.ReceiveTimeout, data1, AppDomain);
        }
 
        [NonEvent]
        public void ReceiveTimeout(string data1)
        {
            ReceiveTimeout(data1, "");
        }
 
        public bool ReliableSessionChannelFaultedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ReliableSessionChannelFaulted, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = Opcodes.ReliableSessionFaulted, Task = Tasks.ReliableSession, Keywords = Keywords.Channel,
            Message = "SessionId:{0} faulted.")]
        public void ReliableSessionChannelFaulted(string SessionId, string AppDomain)
        {
            WriteEvent(EventIds.ReliableSessionChannelFaulted, SessionId, AppDomain);
        }
 
        [NonEvent]
        public void ReliableSessionChannelFaulted(string SessionId)
        {
            ReliableSessionChannelFaulted(SessionId, "");
        }
 
        public bool ConnectionPoolMissIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.ConnectionPoolMiss, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.ConnectionPooling, Keywords = Keywords.Channel | ChannelKeywords.Debug,
            Message = "Pool for {0} has no available connection and {1} busy connections.")]
        public void ConnectionPoolMiss(string PoolKey, int busy, string AppDomain)
        {
            WriteEvent(EventIds.ConnectionPoolMiss, PoolKey, busy, AppDomain);
        }
 
        [NonEvent]
        public void ConnectionPoolMiss(string PoolKey, int busy)
        {
            ConnectionPoolMiss(PoolKey, busy, "");
        }
 
        public bool StreamedMessageReadByEncoderIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.StreamedMessageReadByEncoder, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.MessageDecoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "A streamed message was read by the encoder.")]
        public void StreamedMessageReadByEncoder(string AppDomain)
        {
            WriteEvent(EventIds.StreamedMessageReadByEncoder, AppDomain);
        }
 
        [NonEvent]
        public void StreamedMessageReadByEncoder(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            StreamedMessageReadByEncoder("");
        }
 
        public bool StreamedMessageWrittenByEncoderIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Channel, EventChannel.Debug);
        }
 
        [Event(EventIds.StreamedMessageWrittenByEncoder, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.MessageEncoding, Keywords = Keywords.Channel | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "A streamed message was written by the encoder.")]
        public void StreamedMessageWrittenByEncoder(string AppDomain)
        {
            WriteEvent(EventIds.StreamedMessageWrittenByEncoder, AppDomain);
        }
 
        [NonEvent]
        public void StreamedMessageWrittenByEncoder(EventTraceActivity eventTraceActivity)
        {
            SetActivityId(eventTraceActivity);
            StreamedMessageWrittenByEncoder("");
        }
 
        public bool WebSocketConnectionRequestSendStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketConnectionRequestSendStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocket connection request to '{0}' send start.")]
        public void WebSocketConnectionRequestSendStart(string remoteAddress, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketConnectionRequestSendStart, remoteAddress, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketConnectionRequestSendStart(EventTraceActivity eventTraceActivity, string remoteAddress)
        {
            SetActivityId(eventTraceActivity);
            WebSocketConnectionRequestSendStart(remoteAddress, "");
        }
 
        public bool WebSocketConnectionRequestSendStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketConnectionRequestSendStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocketId:{0} connection request sent.")]
        public void WebSocketConnectionRequestSendStop(int websocketId, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketConnectionRequestSendStop, websocketId, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketConnectionRequestSendStop(EventTraceActivity eventTraceActivity, int websocketId)
        {
            SetActivityId(eventTraceActivity);
            WebSocketConnectionRequestSendStop(websocketId, "");
        }
 
        public bool WebSocketConnectionFailedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.HTTP, EventChannel.Analytic);
        }
 
        [Event(EventIds.WebSocketConnectionFailed, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Analytic,
            Message = "WebSocket connection request failed: '{0}'")]
        public void WebSocketConnectionFailed(string errorMessage, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketConnectionFailed, errorMessage, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketConnectionFailed(EventTraceActivity eventTraceActivity, string errorMessage)
        {
            SetActivityId(eventTraceActivity);
            WebSocketConnectionFailed(errorMessage, "");
        }
 
        public bool WebSocketConnectionAbortedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.HTTP, EventChannel.Analytic);
        }
 
        [Event(EventIds.WebSocketConnectionAborted, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Analytic,
            Message = "WebSocketId:{0} connection is aborted.")]
        public void WebSocketConnectionAborted(int websocketId, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketConnectionAborted, websocketId, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketConnectionAborted(EventTraceActivity eventTraceActivity, int websocketId)
        {
            SetActivityId(eventTraceActivity);
            WebSocketConnectionAborted(websocketId, "");
        }
 
        public bool WebSocketAsyncWriteStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketAsyncWriteStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.TransportSend, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocketId:{0} writing '{1}' bytes to '{2}'.")]
        public void WebSocketAsyncWriteStart(int websocketId, int byteCount, string remoteAddress, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketAsyncWriteStart, websocketId, byteCount, remoteAddress, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketAsyncWriteStart(int websocketId, int byteCount, string remoteAddress)
        {
            WebSocketAsyncWriteStart(websocketId, byteCount, remoteAddress, "");
        }
 
        public bool WebSocketAsyncWriteStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketAsyncWriteStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.TransportSend, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocketId:{0} asynchronous write stop.")]
        public void WebSocketAsyncWriteStop(int websocketId, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketAsyncWriteStop, websocketId, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketAsyncWriteStop(int websocketId)
        {
            WebSocketAsyncWriteStop(websocketId, "");
        }
 
        public bool WebSocketAsyncReadStartIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketAsyncReadStart, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Start, Task = Tasks.TransportReceive, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocketId:{0} read start.")]
        public void WebSocketAsyncReadStart(int websocketId, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketAsyncReadStart, websocketId, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketAsyncReadStart(int websocketId)
        {
            WebSocketAsyncReadStart(websocketId, "");
        }
 
        public bool WebSocketAsyncReadStopIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketAsyncReadStop, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Stop, Task = Tasks.TransportReceive, Keywords = Keywords.HTTP | ChannelKeywords.Debug, ActivityOptions = EventActivityOptions.Disable,
            Message = "WebSocketId:{0} read '{1}' bytes from '{2}'.")]
        public void WebSocketAsyncReadStop(int websocketId, int byteCount, string remoteAddress, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketAsyncReadStop, websocketId, byteCount, remoteAddress, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketAsyncReadStop(int websocketId, int byteCount, string remoteAddress)
        {
            WebSocketAsyncReadStop(websocketId, byteCount, remoteAddress, "");
        }
 
        public bool WebSocketCloseSentIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketCloseSent, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug,
            Message = "WebSocketId:{0} sending close message to '{1}' with close status '{2}'.")]
        public void WebSocketCloseSent(int websocketId, string remoteAddress, string closeStatus, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketCloseSent, websocketId, remoteAddress, closeStatus, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketCloseSent(int websocketId, string remoteAddress, string closeStatus)
        {
            WebSocketCloseSent(websocketId, remoteAddress, closeStatus, "");
        }
 
        public bool WebSocketCloseOutputSentIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketCloseOutputSent, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug,
            Message = "WebSocketId:{0} sending close output message to '{1}' with close status '{2}'.")]
        public void WebSocketCloseOutputSent(int websocketId, string remoteAddress, string closeStatus, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketCloseOutputSent, websocketId, remoteAddress, closeStatus, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketCloseOutputSent(int websocketId, string remoteAddress, string closeStatus)
        {
            WebSocketCloseOutputSent(websocketId, remoteAddress, closeStatus, "");
        }
 
        public bool WebSocketConnectionClosedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketConnectionClosed, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug,
            Message = "WebSocketId:{0} connection closed.")]
        public void WebSocketConnectionClosed(int websocketId, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketConnectionClosed, websocketId, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketConnectionClosed(int websocketId)
        {
            WebSocketConnectionClosed(websocketId, "");
        }
 
        public bool WebSocketCloseStatusReceivedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketCloseStatusReceived, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug,
            Message = "WebSocketId:{0} connection close message received with status '{1}'.")]
        public void WebSocketCloseStatusReceived(int websocketId, string closeStatus, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketCloseStatusReceived, websocketId, closeStatus, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketCloseStatusReceived(int websocketId, string closeStatus)
        {
            WebSocketCloseStatusReceived(websocketId, closeStatus, "");
        }
 
        public bool WebSocketCreateClientWebSocketWithFactoryIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.HTTP, EventChannel.Debug);
        }
 
        [Event(EventIds.WebSocketCreateClientWebSocketWithFactory, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.Connect, Keywords = Keywords.HTTP | ChannelKeywords.Debug,
            Message = "Creating the client WebSocket with a factory of type '{0}'.")]
        public void WebSocketCreateClientWebSocketWithFactory(string clientWebSocketFactoryType, string AppDomain)
        {
            WriteEvent(EventIds.WebSocketCreateClientWebSocketWithFactory, clientWebSocketFactoryType, AppDomain);
        }
 
        [NonEvent]
        public void WebSocketCreateClientWebSocketWithFactory(EventTraceActivity eventTraceActivity, string clientWebSocketFactoryType)
        {
            SetActivityId(eventTraceActivity);
            WebSocketCreateClientWebSocketWithFactory(clientWebSocketFactoryType, "");
        }
 
        public bool WindowsStreamSecurityOnInitiateUpgradeIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Analytic);
        }
 
        [Event(EventIds.WindowsStreamSecurityOnInitiateUpgrade, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = Opcodes.SessionUpgradeInitiate, Task = Tasks.SessionUpgrade, Keywords = Keywords.Security | ChannelKeywords.Analytic,
            Message = "WindowsStreamSecurity initiating security upgrade.")]
        public void WindowsStreamSecurityOnInitiateUpgrade(string AppDomain)
        {
            WriteEvent(EventIds.WindowsStreamSecurityOnInitiateUpgrade, AppDomain);
        }
 
        [NonEvent]
        public void WindowsStreamSecurityOnInitiateUpgrade()
        {
            WindowsStreamSecurityOnInitiateUpgrade("");
        }
 
        public bool TokenValidationStartedIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Debug);
        }
 
        [Event(EventIds.TokenValidationStarted, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.TokenValidation, Keywords = Keywords.Security | ChannelKeywords.Debug,
            Message = "SecurityToken (type '{0}' and id '{1}') validation started.")]
        public void TokenValidationStarted(string tokenType, string tokenID, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.TokenValidationStarted, tokenType, tokenID, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void TokenValidationStarted(EventTraceActivity eventTraceActivity, string tokenType, string tokenID)
        {
            SetActivityId(eventTraceActivity);
            TokenValidationStarted(tokenType, tokenID, "", "");
        }
 
        public bool TokenValidationSuccessIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Security, EventChannel.Debug);
        }
 
        [Event(EventIds.TokenValidationSuccess, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.TokenValidation, Keywords = Keywords.Security | ChannelKeywords.Debug,
            Message = "SecurityToken (type '{0}' and id '{1}') validation succeeded.")]
        public void TokenValidationSuccess(string tokenType, string tokenID, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.TokenValidationSuccess, tokenType, tokenID, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void TokenValidationSuccess(EventTraceActivity eventTraceActivity, string tokenType, string tokenID)
        {
            SetActivityId(eventTraceActivity);
            TokenValidationSuccess(tokenType, tokenID, "", "");
        }
 
        public bool TokenValidationFailureIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Security, EventChannel.Debug);
        }
 
        [Event(EventIds.TokenValidationFailure, Level = EventLevel.Error, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Task = Tasks.TokenValidation, Keywords = Keywords.Security | ChannelKeywords.Debug,
            Message = "SecurityToken (type '{0}' and id '{1}') validation failed. {2}")]
        public void TokenValidationFailure(string tokenType, string tokenID, string errorMessage, string HostReference, string AppDomain)
        {
            WriteEvent(EventIds.TokenValidationFailure, tokenType, tokenID, errorMessage, HostReference, AppDomain);
        }
 
        [NonEvent]
        public void TokenValidationFailure(EventTraceActivity eventTraceActivity, string tokenType, string tokenID, string errorMessage)
        {
            SetActivityId(eventTraceActivity);
            TokenValidationFailure(tokenType, tokenID, errorMessage, "", "");
        }
 
        public bool ShipAssertExceptionMessageIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.ShipAssertExceptionMessage, Level = EventLevel.Error, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "An unexpected failure occurred. Applications should not attempt to handle this error. For diagnostic purposes, this English message is associated with the failure: {0}.")]
        public void ShipAssertExceptionMessage(string data1, string AppDomain)
        {
            WriteEvent(EventIds.ShipAssertExceptionMessage, data1, AppDomain);
        }
 
        [NonEvent]
        public void ShipAssertExceptionMessage(string data1)
        {
            ShipAssertExceptionMessage(data1, "");
        }
 
        public bool UnhandledExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Critical, Keywords.Infrastructure, EventChannel.Operational);
        }
 
        [Event(EventIds.UnhandledException, Level = EventLevel.Critical, Channel = EventChannel.Operational, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Operational,
            Message = "Unhandled exception.  Exception details: {0}")]
        public void UnhandledException(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.UnhandledException, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void UnhandledException(string data1, string SerializedException)
        {
            UnhandledException(data1, SerializedException, "");
        }
 
        public bool TraceCodeEventLogCriticalIsEnabled()
        {
            return base.IsEnabled(EventLevel.Critical, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.TraceCodeEventLogCritical, Level = EventLevel.Critical, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Wrote to the EventLog.")]
        public void TraceCodeEventLogCritical(string ExtendedData, string AppDomain)
        {
            WriteEvent(EventIds.TraceCodeEventLogCritical, ExtendedData, AppDomain);
        }
 
        [NonEvent]
        public void TraceCodeEventLogCritical(string ExtendedData)
        {
            TraceCodeEventLogCritical(ExtendedData, "");
        }
 
        public bool TraceCodeEventLogErrorIsEnabled()
        {
            return base.IsEnabled(EventLevel.Error, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.TraceCodeEventLogError, Level = EventLevel.Error, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Wrote to the EventLog.")]
        public void TraceCodeEventLogError(string ExtendedData, string AppDomain)
        {
            WriteEvent(EventIds.TraceCodeEventLogError, ExtendedData, AppDomain);
        }
 
        [NonEvent]
        public void TraceCodeEventLogError(string ExtendedData)
        {
            TraceCodeEventLogError(ExtendedData, "");
        }
 
        public bool TraceCodeEventLogInfoIsEnabled()
        {
            return base.IsEnabled(EventLevel.Informational, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.TraceCodeEventLogInfo, Level = EventLevel.Informational, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Wrote to the EventLog.")]
        public void TraceCodeEventLogInfo(string ExtendedData, string AppDomain)
        {
            WriteEvent(EventIds.TraceCodeEventLogInfo, ExtendedData, AppDomain);
        }
 
        [NonEvent]
        public void TraceCodeEventLogInfo(string ExtendedData)
        {
            TraceCodeEventLogInfo(ExtendedData, "");
        }
 
        public bool TraceCodeEventLogVerboseIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.TraceCodeEventLogVerbose, Level = EventLevel.Verbose, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Wrote to the EventLog.")]
        public void TraceCodeEventLogVerbose(string ExtendedData, string AppDomain)
        {
            WriteEvent(EventIds.TraceCodeEventLogVerbose, ExtendedData, AppDomain);
        }
 
        [NonEvent]
        public void TraceCodeEventLogVerbose(string ExtendedData)
        {
            TraceCodeEventLogVerbose(ExtendedData, "");
        }
 
        public bool TraceCodeEventLogWarningIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.Infrastructure, EventChannel.Debug);
        }
 
        [Event(EventIds.TraceCodeEventLogWarning, Level = EventLevel.Warning, Channel = EventChannel.Debug, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Debug,
            Message = "Wrote to the EventLog.")]
        public void TraceCodeEventLogWarning(string ExtendedData, string AppDomain)
        {
            WriteEvent(EventIds.TraceCodeEventLogWarning, ExtendedData, AppDomain);
        }
 
        [NonEvent]
        public void TraceCodeEventLogWarning(string ExtendedData)
        {
            TraceCodeEventLogWarning(ExtendedData, "");
        }
 
        public bool ThrowingExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.ThrowingException, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Throwing an exception. Source: {0}. Exception details: {1}")]
        public void ThrowingException(string data1, string data2, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.ThrowingException, data1, data2, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void ThrowingException(string data1, string data2, string SerializedException)
        {
            ThrowingException(data1, data2, SerializedException, "");
        }
 
        public bool ThrowingExceptionVerboseIsEnabled()
        {
            return base.IsEnabled(EventLevel.Verbose, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.ThrowingExceptionVerbose, Level = EventLevel.Verbose, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Throwing an exception. Source: {0}. Exception details: {1}")]
        public void ThrowingExceptionVerbose(string data1, string data2, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.ThrowingExceptionVerbose, data1, data2, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void ThrowingExceptionVerbose(string data1, string data2, string SerializedException)
        {
            ThrowingExceptionVerbose(data1, data2, SerializedException, "");
        }
 
        public bool ThrowingEtwExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Warning, Keywords.Infrastructure, EventChannel.Analytic);
        }
 
        [Event(EventIds.ThrowingEtwException, Level = EventLevel.Warning, Channel = EventChannel.Analytic, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Analytic,
            Message = "Throwing an exception. Source: {0}. Exception details: {1}")]
        public void ThrowingEtwException(string data1, string data2, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.ThrowingEtwException, data1, data2, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void ThrowingEtwException(string data1, string data2, string SerializedException)
        {
            ThrowingEtwException(data1, data2, SerializedException, "");
        }
 
        public bool EtwUnhandledExceptionIsEnabled()
        {
            return base.IsEnabled(EventLevel.Critical, Keywords.Infrastructure, EventChannel.Operational);
        }
 
        [Event(EventIds.EtwUnhandledException, Level = EventLevel.Critical, Channel = EventChannel.Operational, Opcode = EventOpcode.Info, Keywords = Keywords.Infrastructure | ChannelKeywords.Operational,
            Message = "Unhandled exception. Exception details: {0}")]
        public void EtwUnhandledException(string data1, string SerializedException, string AppDomain)
        {
            WriteEvent(EventIds.EtwUnhandledException, data1, SerializedException, AppDomain);
        }
 
        [NonEvent]
        public void EtwUnhandledException(string data1, string SerializedException)
        {
            EtwUnhandledException(data1, SerializedException, "");
        }
 
        [NonEvent]
        private void TransferActivityId(EventTraceActivity eventTraceActivity)
        {
            if (eventTraceActivity != null)
            {
                Guid oldGuid;
                SetCurrentThreadActivityId(eventTraceActivity.ActivityId, out oldGuid);
            }
        }
 
        [NonEvent]
        private void SetActivityId(EventTraceActivity eventTraceActivity)
        {
            if (eventTraceActivity != null)
            {
                SetCurrentThreadActivityId(eventTraceActivity.ActivityId);
            }
        }
 
        #region Keywords / Tasks / Opcodes
 
        public partial class EventIds
        {
            public const int WorkflowInstanceRecord = 100;
            public const int WorkflowInstanceUnhandledExceptionRecord = 101;
            public const int WorkflowInstanceAbortedRecord = 102;
            public const int ActivityStateRecord = 103;
            public const int ActivityScheduledRecord = 104;
            public const int FaultPropagationRecord = 105;
            public const int CancelRequestedRecord = 106;
            public const int BookmarkResumptionRecord = 107;
            public const int CustomTrackingRecordInfo = 108;
            public const int CustomTrackingRecordWarning = 110;
            public const int CustomTrackingRecordError = 111;
            public const int WorkflowInstanceSuspendedRecord = 112;
            public const int WorkflowInstanceTerminatedRecord = 113;
            public const int WorkflowInstanceRecordWithId = 114;
            public const int WorkflowInstanceAbortedRecordWithId = 115;
            public const int WorkflowInstanceSuspendedRecordWithId = 116;
            public const int WorkflowInstanceTerminatedRecordWithId = 117;
            public const int WorkflowInstanceUnhandledExceptionRecordWithId = 118;
            public const int WorkflowInstanceUpdatedRecord = 119;
            public const int BufferPoolAllocation = 131;
            public const int BufferPoolChangeQuota = 132;
            public const int ActionItemScheduled = 133;
            public const int ActionItemCallbackInvoked = 134;
            public const int ClientMessageInspectorAfterReceiveInvoked = 201;
            public const int ClientMessageInspectorBeforeSendInvoked = 202;
            public const int ClientParameterInspectorAfterCallInvoked = 203;
            public const int ClientParameterInspectorBeforeCallInvoked = 204;
            public const int OperationInvoked = 205;
            public const int ErrorHandlerInvoked = 206;
            public const int FaultProviderInvoked = 207;
            public const int MessageInspectorAfterReceiveInvoked = 208;
            public const int MessageInspectorBeforeSendInvoked = 209;
            public const int MessageThrottleExceeded = 210;
            public const int ParameterInspectorAfterCallInvoked = 211;
            public const int ParameterInspectorBeforeCallInvoked = 212;
            public const int ServiceHostStarted = 213;
            public const int OperationCompleted = 214;
            public const int MessageReceivedByTransport = 215;
            public const int MessageSentByTransport = 216;
            public const int ClientOperationPrepared = 217;
            public const int ServiceChannelCallStop = 218;
            public const int ServiceException = 219;
            public const int MessageSentToTransport = 220;
            public const int MessageReceivedFromTransport = 221;
            public const int OperationFailed = 222;
            public const int OperationFaulted = 223;
            public const int MessageThrottleAtSeventyPercent = 224;
            public const int TraceCorrelationKeys = 225;
            public const int IdleServicesClosed = 226;
            public const int UserDefinedErrorOccurred = 301;
            public const int UserDefinedWarningOccurred = 302;
            public const int UserDefinedInformationEventOccurred = 303;
            public const int StopSignpostEvent = 401;
            public const int StartSignpostEvent = 402;
            public const int SuspendSignpostEvent = 403;
            public const int ResumeSignpostEvent = 404;
            public const int StartSignpostEvent1 = 440;
            public const int StopSignpostEvent1 = 441;
            public const int MessageLogInfo = 451;
            public const int MessageLogWarning = 452;
            public const int TransferEmitted = 499;
            public const int CompilationStart = 501;
            public const int CompilationStop = 502;
            public const int ServiceHostFactoryCreationStart = 503;
            public const int ServiceHostFactoryCreationStop = 504;
            public const int CreateServiceHostStart = 505;
            public const int CreateServiceHostStop = 506;
            public const int HostedTransportConfigurationManagerConfigInitStart = 507;
            public const int HostedTransportConfigurationManagerConfigInitStop = 508;
            public const int ServiceHostOpenStart = 509;
            public const int ServiceHostOpenStop = 510;
            public const int WebHostRequestStart = 513;
            public const int WebHostRequestStop = 514;
            public const int CBAEntryRead = 601;
            public const int CBAMatchFound = 602;
            public const int AspNetRoutingService = 603;
            public const int AspNetRoute = 604;
            public const int IncrementBusyCount = 605;
            public const int DecrementBusyCount = 606;
            public const int ServiceChannelOpenStart = 701;
            public const int ServiceChannelOpenStop = 702;
            public const int ServiceChannelCallStart = 703;
            public const int ServiceChannelBeginCallStart = 704;
            public const int HttpSendMessageStart = 706;
            public const int HttpSendStop = 707;
            public const int HttpMessageReceiveStart = 708;
            public const int DispatchMessageStart = 709;
            public const int HttpContextBeforeProcessAuthentication = 710;
            public const int DispatchMessageBeforeAuthorization = 711;
            public const int DispatchMessageStop = 712;
            public const int ClientChannelOpenStart = 715;
            public const int ClientChannelOpenStop = 716;
            public const int HttpSendStreamedMessageStart = 717;
            public const int WorkflowApplicationCompleted = 1001;
            public const int WorkflowApplicationTerminated = 1002;
            public const int WorkflowInstanceCanceled = 1003;
            public const int WorkflowInstanceAborted = 1004;
            public const int WorkflowApplicationIdled = 1005;
            public const int WorkflowApplicationUnhandledException = 1006;
            public const int WorkflowApplicationPersisted = 1007;
            public const int WorkflowApplicationUnloaded = 1008;
            public const int ActivityScheduled = 1009;
            public const int ActivityCompleted = 1010;
            public const int ScheduleExecuteActivityWorkItem = 1011;
            public const int StartExecuteActivityWorkItem = 1012;
            public const int CompleteExecuteActivityWorkItem = 1013;
            public const int ScheduleCompletionWorkItem = 1014;
            public const int StartCompletionWorkItem = 1015;
            public const int CompleteCompletionWorkItem = 1016;
            public const int ScheduleCancelActivityWorkItem = 1017;
            public const int StartCancelActivityWorkItem = 1018;
            public const int CompleteCancelActivityWorkItem = 1019;
            public const int CreateBookmark = 1020;
            public const int ScheduleBookmarkWorkItem = 1021;
            public const int StartBookmarkWorkItem = 1022;
            public const int CompleteBookmarkWorkItem = 1023;
            public const int CreateBookmarkScope = 1024;
            public const int BookmarkScopeInitialized = 1025;
            public const int ScheduleTransactionContextWorkItem = 1026;
            public const int StartTransactionContextWorkItem = 1027;
            public const int CompleteTransactionContextWorkItem = 1028;
            public const int ScheduleFaultWorkItem = 1029;
            public const int StartFaultWorkItem = 1030;
            public const int CompleteFaultWorkItem = 1031;
            public const int ScheduleRuntimeWorkItem = 1032;
            public const int StartRuntimeWorkItem = 1033;
            public const int CompleteRuntimeWorkItem = 1034;
            public const int RuntimeTransactionSet = 1035;
            public const int RuntimeTransactionCompletionRequested = 1036;
            public const int RuntimeTransactionComplete = 1037;
            public const int EnterNoPersistBlock = 1038;
            public const int ExitNoPersistBlock = 1039;
            public const int InArgumentBound = 1040;
            public const int WorkflowApplicationPersistableIdle = 1041;
            public const int WorkflowActivityStart = 1101;
            public const int WorkflowActivityStop = 1102;
            public const int WorkflowActivitySuspend = 1103;
            public const int WorkflowActivityResume = 1104;
            public const int InvokeMethodIsStatic = 1124;
            public const int InvokeMethodIsNotStatic = 1125;
            public const int InvokedMethodThrewException = 1126;
            public const int InvokeMethodUseAsyncPattern = 1131;
            public const int InvokeMethodDoesNotUseAsyncPattern = 1132;
            public const int FlowchartStart = 1140;
            public const int FlowchartEmpty = 1141;
            public const int FlowchartNextNull = 1143;
            public const int FlowchartSwitchCase = 1146;
            public const int FlowchartSwitchDefault = 1147;
            public const int FlowchartSwitchCaseNotFound = 1148;
            public const int CompensationState = 1150;
            public const int SwitchCaseNotFound = 1223;
            public const int ChannelInitializationTimeout = 1400;
            public const int CloseTimeout = 1401;
            public const int IdleTimeout = 1402;
            public const int LeaseTimeout = 1403;
            public const int OpenTimeout = 1405;
            public const int ReceiveTimeout = 1406;
            public const int SendTimeout = 1407;
            public const int InactivityTimeout = 1409;
            public const int MaxReceivedMessageSizeExceeded = 1416;
            public const int MaxSentMessageSizeExceeded = 1417;
            public const int MaxOutboundConnectionsPerEndpointExceeded = 1418;
            public const int MaxPendingConnectionsExceeded = 1419;
            public const int ReaderQuotaExceeded = 1420;
            public const int NegotiateTokenAuthenticatorStateCacheExceeded = 1422;
            public const int NegotiateTokenAuthenticatorStateCacheRatio = 1423;
            public const int SecuritySessionRatio = 1424;
            public const int PendingConnectionsRatio = 1430;
            public const int ConcurrentCallsRatio = 1431;
            public const int ConcurrentSessionsRatio = 1432;
            public const int OutboundConnectionsPerEndpointRatio = 1433;
            public const int PendingMessagesPerChannelRatio = 1436;
            public const int ConcurrentInstancesRatio = 1438;
            public const int PendingAcceptsAtZero = 1439;
            public const int MaxSessionSizeReached = 1441;
            public const int ReceiveRetryCountReached = 1442;
            public const int MaxRetryCyclesExceededMsmq = 1443;
            public const int ReadPoolMiss = 1445;
            public const int WritePoolMiss = 1446;
            public const int WfMessageReceived = 1449;
            public const int WfMessageSent = 1450;
            public const int MaxRetryCyclesExceeded = 1451;
            public const int ExecuteWorkItemStart = 2021;
            public const int ExecuteWorkItemStop = 2022;
            public const int SendMessageChannelCacheMiss = 2023;
            public const int InternalCacheMetadataStart = 2024;
            public const int InternalCacheMetadataStop = 2025;
            public const int CompileVbExpressionStart = 2026;
            public const int CacheRootMetadataStart = 2027;
            public const int CacheRootMetadataStop = 2028;
            public const int CompileVbExpressionStop = 2029;
            public const int TryCatchExceptionFromTry = 2576;
            public const int TryCatchExceptionDuringCancelation = 2577;
            public const int TryCatchExceptionFromCatchOrFinally = 2578;
            public const int ReceiveContextCompleteFailed = 3300;
            public const int ReceiveContextAbandonFailed = 3301;
            public const int ReceiveContextFaulted = 3302;
            public const int ReceiveContextAbandonWithException = 3303;
            public const int ClientBaseCachedChannelFactoryCount = 3305;
            public const int ClientBaseChannelFactoryAgedOutofCache = 3306;
            public const int ClientBaseChannelFactoryCacheHit = 3307;
            public const int ClientBaseUsingLocalChannelFactory = 3308;
            public const int QueryCompositionExecuted = 3309;
            public const int DispatchFailed = 3310;
            public const int DispatchSuccessful = 3311;
            public const int MessageReadByEncoder = 3312;
            public const int MessageWrittenByEncoder = 3313;
            public const int SessionIdleTimeout = 3314;
            public const int SocketAcceptEnqueued = 3319;
            public const int SocketAccepted = 3320;
            public const int ConnectionPoolMiss = 3321;
            public const int DispatchFormatterDeserializeRequestStart = 3322;
            public const int DispatchFormatterDeserializeRequestStop = 3323;
            public const int DispatchFormatterSerializeReplyStart = 3324;
            public const int DispatchFormatterSerializeReplyStop = 3325;
            public const int ClientFormatterSerializeRequestStart = 3326;
            public const int ClientFormatterSerializeRequestStop = 3327;
            public const int ClientFormatterDeserializeReplyStart = 3328;
            public const int ClientFormatterDeserializeReplyStop = 3329;
            public const int SecurityNegotiationStart = 3330;
            public const int SecurityNegotiationStop = 3331;
            public const int SecurityTokenProviderOpened = 3332;
            public const int OutgoingMessageSecured = 3333;
            public const int IncomingMessageVerified = 3334;
            public const int GetServiceInstanceStart = 3335;
            public const int GetServiceInstanceStop = 3336;
            public const int ChannelReceiveStart = 3337;
            public const int ChannelReceiveStop = 3338;
            public const int ChannelFactoryCreated = 3339;
            public const int PipeConnectionAcceptStart = 3340;
            public const int PipeConnectionAcceptStop = 3341;
            public const int EstablishConnectionStart = 3342;
            public const int EstablishConnectionStop = 3343;
            public const int SessionPreambleUnderstood = 3345;
            public const int ConnectionReaderSendFault = 3346;
            public const int SocketAcceptClosed = 3347;
            public const int ServiceHostFaulted = 3348;
            public const int ListenerOpenStart = 3349;
            public const int ListenerOpenStop = 3350;
            public const int ServerMaxPooledConnectionsQuotaReached = 3351;
            public const int TcpConnectionTimedOut = 3352;
            public const int TcpConnectionResetError = 3353;
            public const int ServiceSecurityNegotiationCompleted = 3354;
            public const int SecurityNegotiationProcessingFailure = 3355;
            public const int SecurityIdentityVerificationSuccess = 3356;
            public const int SecurityIdentityVerificationFailure = 3357;
            public const int PortSharingDuplicatedSocket = 3358;
            public const int SecurityImpersonationSuccess = 3359;
            public const int SecurityImpersonationFailure = 3360;
            public const int HttpChannelRequestAborted = 3361;
            public const int HttpChannelResponseAborted = 3362;
            public const int HttpAuthFailed = 3363;
            public const int SharedListenerProxyRegisterStart = 3364;
            public const int SharedListenerProxyRegisterStop = 3365;
            public const int SharedListenerProxyRegisterFailed = 3366;
            public const int ConnectionPoolPreambleFailed = 3367;
            public const int SslOnInitiateUpgrade = 3368;
            public const int SslOnAcceptUpgrade = 3369;
            public const int BinaryMessageEncodingStart = 3370;
            public const int MtomMessageEncodingStart = 3371;
            public const int TextMessageEncodingStart = 3372;
            public const int BinaryMessageDecodingStart = 3373;
            public const int MtomMessageDecodingStart = 3374;
            public const int TextMessageDecodingStart = 3375;
            public const int HttpResponseReceiveStart = 3376;
            public const int SocketReadStop = 3377;
            public const int SocketAsyncReadStop = 3378;
            public const int SocketWriteStart = 3379;
            public const int SocketAsyncWriteStart = 3380;
            public const int SequenceAcknowledgementSent = 3381;
            public const int ClientReliableSessionReconnect = 3382;
            public const int ReliableSessionChannelFaulted = 3383;
            public const int WindowsStreamSecurityOnInitiateUpgrade = 3384;
            public const int WindowsStreamSecurityOnAcceptUpgrade = 3385;
            public const int SocketConnectionAbort = 3386;
            public const int HttpGetContextStart = 3388;
            public const int ClientSendPreambleStart = 3389;
            public const int ClientSendPreambleStop = 3390;
            public const int HttpMessageReceiveFailed = 3391;
            public const int TransactionScopeCreate = 3392;
            public const int StreamedMessageReadByEncoder = 3393;
            public const int StreamedMessageWrittenByEncoder = 3394;
            public const int MessageWrittenAsynchronouslyByEncoder = 3395;
            public const int BufferedAsyncWriteStart = 3396;
            public const int BufferedAsyncWriteStop = 3397;
            public const int PipeSharedMemoryCreated = 3398;
            public const int NamedPipeCreated = 3399;
            public const int SignatureVerificationStart = 3401;
            public const int SignatureVerificationSuccess = 3402;
            public const int WrappedKeyDecryptionStart = 3403;
            public const int WrappedKeyDecryptionSuccess = 3404;
            public const int EncryptedDataProcessingStart = 3405;
            public const int EncryptedDataProcessingSuccess = 3406;
            public const int HttpPipelineProcessInboundRequestStart = 3407;
            public const int HttpPipelineBeginProcessInboundRequestStart = 3408;
            public const int HttpPipelineProcessInboundRequestStop = 3409;
            public const int HttpPipelineFaulted = 3410;
            public const int HttpPipelineTimeoutException = 3411;
            public const int HttpPipelineProcessResponseStart = 3412;
            public const int HttpPipelineBeginProcessResponseStart = 3413;
            public const int HttpPipelineProcessResponseStop = 3414;
            public const int WebSocketConnectionRequestSendStart = 3415;
            public const int WebSocketConnectionRequestSendStop = 3416;
            public const int WebSocketConnectionAcceptStart = 3417;
            public const int WebSocketConnectionAccepted = 3418;
            public const int WebSocketConnectionDeclined = 3419;
            public const int WebSocketConnectionFailed = 3420;
            public const int WebSocketConnectionAborted = 3421;
            public const int WebSocketAsyncWriteStart = 3422;
            public const int WebSocketAsyncWriteStop = 3423;
            public const int WebSocketAsyncReadStart = 3424;
            public const int WebSocketAsyncReadStop = 3425;
            public const int WebSocketCloseSent = 3426;
            public const int WebSocketCloseOutputSent = 3427;
            public const int WebSocketConnectionClosed = 3428;
            public const int WebSocketCloseStatusReceived = 3429;
            public const int WebSocketUseVersionFromClientWebSocketFactory = 3430;
            public const int WebSocketCreateClientWebSocketWithFactory = 3431;
            public const int InferredContractDescription = 3501;
            public const int InferredOperationDescription = 3502;
            public const int DuplicateCorrelationQuery = 3503;
            public const int ServiceEndpointAdded = 3507;
            public const int TrackingProfileNotFound = 3508;
            public const int BufferOutOfOrderMessageNoInstance = 3550;
            public const int BufferOutOfOrderMessageNoBookmark = 3551;
            public const int MaxPendingMessagesPerChannelExceeded = 3552;
            public const int XamlServicesLoadStart = 3553;
            public const int XamlServicesLoadStop = 3554;
            public const int CreateWorkflowServiceHostStart = 3555;
            public const int CreateWorkflowServiceHostStop = 3556;
            public const int TransactedReceiveScopeEndCommitFailed = 3557;
            public const int ServiceActivationStart = 3558;
            public const int ServiceActivationStop = 3559;
            public const int ServiceActivationAvailableMemory = 3560;
            public const int ServiceActivationException = 3561;
            public const int RoutingServiceClosingClient = 3800;
            public const int RoutingServiceChannelFaulted = 3801;
            public const int RoutingServiceCompletingOneWay = 3802;
            public const int RoutingServiceProcessingFailure = 3803;
            public const int RoutingServiceCreatingClientForEndpoint = 3804;
            public const int RoutingServiceDisplayConfig = 3805;
            public const int RoutingServiceCompletingTwoWay = 3807;
            public const int RoutingServiceMessageRoutedToEndpoints = 3809;
            public const int RoutingServiceConfigurationApplied = 3810;
            public const int RoutingServiceProcessingMessage = 3815;
            public const int RoutingServiceTransmittingMessage = 3816;
            public const int RoutingServiceCommittingTransaction = 3817;
            public const int RoutingServiceDuplexCallbackException = 3818;
            public const int RoutingServiceMovedToBackup = 3819;
            public const int RoutingServiceCreatingTransaction = 3820;
            public const int RoutingServiceCloseFailed = 3821;
            public const int RoutingServiceSendingResponse = 3822;
            public const int RoutingServiceSendingFaultResponse = 3823;
            public const int RoutingServiceCompletingReceiveContext = 3824;
            public const int RoutingServiceAbandoningReceiveContext = 3825;
            public const int RoutingServiceUsingExistingTransaction = 3826;
            public const int RoutingServiceTransmitFailed = 3827;
            public const int RoutingServiceFilterTableMatchStart = 3828;
            public const int RoutingServiceFilterTableMatchStop = 3829;
            public const int RoutingServiceAbortingChannel = 3830;
            public const int RoutingServiceHandledException = 3831;
            public const int RoutingServiceTransmitSucceeded = 3832;
            public const int TransportListenerSessionsReceived = 4001;
            public const int FailFastException = 4002;
            public const int ServiceStartPipeError = 4003;
            public const int DispatchSessionStart = 4008;
            public const int PendingSessionQueueFull = 4010;
            public const int MessageQueueRegisterStart = 4011;
            public const int MessageQueueRegisterAbort = 4012;
            public const int MessageQueueUnregisterSucceeded = 4013;
            public const int MessageQueueRegisterFailed = 4014;
            public const int MessageQueueRegisterCompleted = 4015;
            public const int MessageQueueDuplicatedSocketError = 4016;
            public const int MessageQueueDuplicatedSocketComplete = 4019;
            public const int TcpTransportListenerListeningStart = 4020;
            public const int TcpTransportListenerListeningStop = 4021;
            public const int WebhostUnregisterProtocolFailed = 4022;
            public const int WasCloseAllListenerChannelInstancesCompleted = 4023;
            public const int WasCloseAllListenerChannelInstancesFailed = 4024;
            public const int OpenListenerChannelInstanceFailed = 4025;
            public const int WasConnected = 4026;
            public const int WasDisconnected = 4027;
            public const int PipeTransportListenerListeningStart = 4028;
            public const int PipeTransportListenerListeningStop = 4029;
            public const int DispatchSessionSuccess = 4030;
            public const int DispatchSessionFailed = 4031;
            public const int WasConnectionTimedout = 4032;
            public const int RoutingTableLookupStart = 4033;
            public const int RoutingTableLookupStop = 4034;
            public const int PendingSessionQueueRatio = 4035;
            public const int EndSqlCommandExecute = 4201;
            public const int StartSqlCommandExecute = 4202;
            public const int RenewLockSystemError = 4203;
            public const int FoundProcessingError = 4205;
            public const int UnlockInstanceException = 4206;
            public const int MaximumRetriesExceededForSqlCommand = 4207;
            public const int RetryingSqlCommandDueToSqlError = 4208;
            public const int TimeoutOpeningSqlConnection = 4209;
            public const int SqlExceptionCaught = 4210;
            public const int QueuingSqlRetry = 4211;
            public const int LockRetryTimeout = 4212;
            public const int RunnableInstancesDetectionError = 4213;
            public const int InstanceLocksRecoveryError = 4214;
            public const int MessageLogEventSizeExceeded = 4600;
            public const int DiscoveryClientInClientChannelFailedToClose = 4801;
            public const int DiscoveryClientProtocolExceptionSuppressed = 4802;
            public const int DiscoveryClientReceivedMulticastSuppression = 4803;
            public const int DiscoveryMessageReceivedAfterOperationCompleted = 4804;
            public const int DiscoveryMessageWithInvalidContent = 4805;
            public const int DiscoveryMessageWithInvalidRelatesToOrOperationCompleted = 4806;
            public const int DiscoveryMessageWithInvalidReplyTo = 4807;
            public const int DiscoveryMessageWithNoContent = 4808;
            public const int DiscoveryMessageWithNullMessageId = 4809;
            public const int DiscoveryMessageWithNullMessageSequence = 4810;
            public const int DiscoveryMessageWithNullRelatesTo = 4811;
            public const int DiscoveryMessageWithNullReplyTo = 4812;
            public const int DuplicateDiscoveryMessage = 4813;
            public const int EndpointDiscoverabilityDisabled = 4814;
            public const int EndpointDiscoverabilityEnabled = 4815;
            public const int FindInitiatedInDiscoveryClientChannel = 4816;
            public const int InnerChannelCreationFailed = 4817;
            public const int InnerChannelOpenFailed = 4818;
            public const int InnerChannelOpenSucceeded = 4819;
            public const int SynchronizationContextReset = 4820;
            public const int SynchronizationContextSetToNull = 4821;
            public const int DCSerializeWithSurrogateStart = 5001;
            public const int DCSerializeWithSurrogateStop = 5002;
            public const int DCDeserializeWithSurrogateStart = 5003;
            public const int DCDeserializeWithSurrogateStop = 5004;
            public const int ImportKnownTypesStart = 5005;
            public const int ImportKnownTypesStop = 5006;
            public const int DCResolverResolve = 5007;
            public const int DCGenWriterStart = 5008;
            public const int DCGenWriterStop = 5009;
            public const int DCGenReaderStart = 5010;
            public const int DCGenReaderStop = 5011;
            public const int DCJsonGenReaderStart = 5012;
            public const int DCJsonGenReaderStop = 5013;
            public const int DCJsonGenWriterStart = 5014;
            public const int DCJsonGenWriterStop = 5015;
            public const int GenXmlSerializableStart = 5016;
            public const int GenXmlSerializableStop = 5017;
            public const int JsonMessageDecodingStart = 5203;
            public const int JsonMessageEncodingStart = 5204;
            public const int TokenValidationStarted = 5402;
            public const int TokenValidationSuccess = 5403;
            public const int TokenValidationFailure = 5404;
            public const int GetIssuerNameSuccess = 5405;
            public const int GetIssuerNameFailure = 5406;
            public const int FederationMessageProcessingStarted = 5600;
            public const int FederationMessageProcessingSuccess = 5601;
            public const int FederationMessageCreationStarted = 5602;
            public const int FederationMessageCreationSuccess = 5603;
            public const int SessionCookieReadingStarted = 5604;
            public const int SessionCookieReadingSuccess = 5605;
            public const int PrincipalSettingFromSessionTokenStarted = 5606;
            public const int PrincipalSettingFromSessionTokenSuccess = 5607;
            public const int TrackingRecordDropped = 39456;
            public const int TrackingRecordRaised = 39457;
            public const int TrackingRecordTruncated = 39458;
            public const int TrackingDataExtracted = 39459;
            public const int TrackingValueNotSerializable = 39460;
            public const int AppDomainUnload = 57393;
            public const int HandledException = 57394;
            public const int ShipAssertExceptionMessage = 57395;
            public const int ThrowingException = 57396;
            public const int UnhandledException = 57397;
            public const int MaxInstancesExceeded = 57398;
            public const int TraceCodeEventLogCritical = 57399;
            public const int TraceCodeEventLogError = 57400;
            public const int TraceCodeEventLogInfo = 57401;
            public const int TraceCodeEventLogVerbose = 57402;
            public const int TraceCodeEventLogWarning = 57403;
            public const int HandledExceptionWarning = 57404;
            public const int HandledExceptionError = 57405;
            public const int HandledExceptionVerbose = 57406;
            public const int ThrowingExceptionVerbose = 57407;
            public const int EtwUnhandledException = 57408;
            public const int ThrowingEtwExceptionVerbose = 57409;
            public const int ThrowingEtwException = 57410;
            public const int HttpHandlerPickedForUrl = 62326;
        }
 
        public partial class Tasks
        {
            public const EventTask ActivationDispatchSession = (EventTask)2500;
            public const EventTask ActivationDuplicateSocket = (EventTask)2501;
            public const EventTask ActivationListenerOpen = (EventTask)2502;
            public const EventTask ActivationPipeListenerListening = (EventTask)2503;
            public const EventTask ActivationRoutingTableLookup = (EventTask)2504;
            public const EventTask ActivationServiceStart = (EventTask)2505;
            public const EventTask ActivationTcpListenerListening = (EventTask)2506;
            public const EventTask AddServiceEndpoint = (EventTask)2507;
            public const EventTask BufferOutOfOrder = (EventTask)2508;
            public const EventTask BufferPooling = (EventTask)2509;
            public const EventTask CacheRootMetadata = (EventTask)2510;
            public const EventTask ChannelFactoryCaching = (EventTask)2511;
            public const EventTask ChannelFactoryCreate = (EventTask)2512;
            public const EventTask ChannelReceive = (EventTask)2513;
            public const EventTask ClientRuntime = (EventTask)2514;
            public const EventTask ClientSendPreamble = (EventTask)2515;
            public const EventTask CompensationState = (EventTask)2516;
            public const EventTask CompleteActivity = (EventTask)2517;
            public const EventTask CompleteWorkItem = (EventTask)2518;
            public const EventTask Connect = (EventTask)2519;
            public const EventTask ConnectionAbort = (EventTask)2520;
            public const EventTask ConnectionAccept = (EventTask)2521;
            public const EventTask ConnectionPooling = (EventTask)2522;
            public const EventTask Correlation = (EventTask)2523;
            public const EventTask CreateBookmark = (EventTask)2524;
            public const EventTask CreateWorkflowServiceHost = (EventTask)2526;
            public const EventTask CustomTrackingRecord = (EventTask)2527;
            public const EventTask DataContractResolver = (EventTask)2528;
            public const EventTask DiscoveryClient = (EventTask)2529;
            public const EventTask DiscoveryClientChannel = (EventTask)2530;
            public const EventTask DiscoveryMessage = (EventTask)2531;
            public const EventTask DiscoverySynchronizationContext = (EventTask)2532;
            public const EventTask DispatchMessage = (EventTask)2533;
            public const EventTask EndpointDiscoverability = (EventTask)2534;
            public const EventTask ExecuteActivity = (EventTask)2535;
            public const EventTask ExecuteFlowchart = (EventTask)2536;
            public const EventTask ExecuteWorkItem = (EventTask)2537;
            public const EventTask FormatterDeserializeReply = (EventTask)2539;
            public const EventTask FormatterDeserializeRequest = (EventTask)2540;
            public const EventTask FormatterSerializeReply = (EventTask)2541;
            public const EventTask FormatterSerializeRequest = (EventTask)2542;
            public const EventTask GenerateDeserializer = (EventTask)2543;
            public const EventTask GenerateSerializer = (EventTask)2544;
            public const EventTask GenerateXmlSerializable = (EventTask)2545;
            public const EventTask HostedTransportConfigurationManagerConfigInit = (EventTask)2546;
            public const EventTask ImportKnownType = (EventTask)2547;
            public const EventTask InferDescription = (EventTask)2548;
            public const EventTask InitializeBookmarkScope = (EventTask)2549;
            public const EventTask InternalCacheMetadata = (EventTask)2550;
            public const EventTask InvokeMethod = (EventTask)2551;
            public const EventTask ListenerOpen = (EventTask)2552;
            public const EventTask LockWorkflowInstance = (EventTask)2553;
            public const EventTask MessageChannelCache = (EventTask)2554;
            public const EventTask MessageDecoding = (EventTask)2555;
            public const EventTask MessageEncoding = (EventTask)2556;
            public const EventTask MessageQueueRegister = (EventTask)2557;
            public const EventTask MsmqQuotas = (EventTask)2558;
            public const EventTask NoPersistBlock = (EventTask)2559;
            public const EventTask Quotas = (EventTask)2560;
            public const EventTask ReliableSession = (EventTask)2561;
            public const EventTask RoutingService = (EventTask)2562;
            public const EventTask RoutingServiceClient = (EventTask)2563;
            public const EventTask RoutingServiceFilterTableMatch = (EventTask)2564;
            public const EventTask RoutingServiceMessage = (EventTask)2565;
            public const EventTask RoutingServiceReceiveContext = (EventTask)2566;
            public const EventTask RoutingServiceTransaction = (EventTask)2567;
            public const EventTask RuntimeTransaction = (EventTask)2568;
            public const EventTask ScheduleActivity = (EventTask)2569;
            public const EventTask ScheduleWorkItem = (EventTask)2570;
            public const EventTask SecureMessage = (EventTask)2571;
            public const EventTask SecurityImpersonation = (EventTask)2572;
            public const EventTask SecurityNegotiation = (EventTask)2573;
            public const EventTask SecurityVerification = (EventTask)2574;
            public const EventTask ServiceActivation = (EventTask)2575;
            public const EventTask ServiceChannelCall = (EventTask)2576;
            public const EventTask ServiceChannelOpen = (EventTask)2577;
            public const EventTask ServiceHostActivation = (EventTask)2578;
            public const EventTask ServiceHostCompilation = (EventTask)2579;
            public const EventTask ServiceHostCreate = (EventTask)2580;
            public const EventTask ServiceHostFactoryCreation = (EventTask)2581;
            public const EventTask ServiceHostFault = (EventTask)2582;
            public const EventTask ServiceHostOpen = (EventTask)2583;
            public const EventTask ServiceInstance = (EventTask)2584;
            public const EventTask ServiceShutdown = (EventTask)2585;
            public const EventTask SessionStart = (EventTask)2586;
            public const EventTask SessionUpgrade = (EventTask)2587;
            public const EventTask Signpost = (EventTask)2588;
            public const EventTask SqlCommandExecute = (EventTask)2589;
            public const EventTask StartWorkItem = (EventTask)2590;
            public const EventTask SurrogateDeserialize = (EventTask)2591;
            public const EventTask SurrogateSerialize = (EventTask)2592;
            public const EventTask ThreadScheduling = (EventTask)2593;
            public const EventTask Throttles = (EventTask)2594;
            public const EventTask Timeout = (EventTask)2595;
            public const EventTask TimeoutException = (EventTask)2596;
            public const EventTask TrackingProfile = (EventTask)2597;
            public const EventTask TrackingRecord = (EventTask)2598;
            public const EventTask TransportReceive = (EventTask)2599;
            public const EventTask TransportSend = (EventTask)2600;
            public const EventTask TryCatchException = (EventTask)2601;
            public const EventTask VBExpressionCompile = (EventTask)2602;
            public const EventTask WASActivation = (EventTask)2603;
            public const EventTask WebHostRequest = (EventTask)2604;
            public const EventTask WFApplicationStateChange = (EventTask)2605;
            public const EventTask WFMessage = (EventTask)2606;
            public const EventTask WorkflowActivity = (EventTask)2607;
            public const EventTask WorkflowInstanceRecord = (EventTask)2608;
            public const EventTask WorkflowTracking = (EventTask)2609;
            public const EventTask XamlServicesLoad = (EventTask)2610;
            public const EventTask SignatureVerification = (EventTask)2611;
            public const EventTask TokenValidation = (EventTask)2612;
            public const EventTask GetIssuerName = (EventTask)2613;
            public const EventTask WrappedKeyDecryption = (EventTask)2614;
            public const EventTask EncryptedDataProcessing = (EventTask)2615;
            public const EventTask FederationMessageProcessing = (EventTask)2616;
            public const EventTask FederationMessageCreation = (EventTask)2617;
            public const EventTask SessionCookieReading = (EventTask)2618;
            public const EventTask PrincipalSetting = (EventTask)2619;
        }
 
        public class Opcodes
        {
            public const EventOpcode BufferOutOfOrderNoBookmark = (EventOpcode)10;
            public const EventOpcode RoutingServiceReceiveContextCompleting = (EventOpcode)100;
            public const EventOpcode RoutingServiceTransactionCommittingTransaction = (EventOpcode)101;
            public const EventOpcode RoutingServiceTransactionCreating = (EventOpcode)102;
            public const EventOpcode RoutingServiceTransactionUsingExisting = (EventOpcode)103;
            public const EventOpcode RuntimeTransactionComplete = (EventOpcode)104;
            public const EventOpcode RuntimeTransactionCompletionRequested = (EventOpcode)105;
            public const EventOpcode RuntimeTransactionSet = (EventOpcode)106;
            public const EventOpcode ScheduleWorkItemScheduleBookmark = (EventOpcode)107;
            public const EventOpcode ScheduleWorkItemScheduleCancelActivity = (EventOpcode)108;
            public const EventOpcode ScheduleWorkItemScheduleCompletion = (EventOpcode)109;
            public const EventOpcode ExecuteFlowchartBegin = (EventOpcode)11;
            public const EventOpcode BufferOutOfOrderNoInstance = (EventOpcode)11;
            public const EventOpcode ScheduleWorkItemScheduleExecuteActivity = (EventOpcode)110;
            public const EventOpcode ScheduleWorkItemScheduleFault = (EventOpcode)111;
            public const EventOpcode ScheduleWorkItemScheduleRuntime = (EventOpcode)112;
            public const EventOpcode ScheduleWorkItemScheduleTransactionContext = (EventOpcode)113;
            public const EventOpcode SessionUpgradeAccept = (EventOpcode)114;
            public const EventOpcode SessionUpgradeInitiate = (EventOpcode)115;
            public const EventOpcode Signpostsuspend = (EventOpcode)116;
            public const EventOpcode StartWorkItemStartBookmark = (EventOpcode)117;
            public const EventOpcode StartWorkItemStartCancelActivity = (EventOpcode)118;
            public const EventOpcode StartWorkItemStartCompletion = (EventOpcode)119;
            public const EventOpcode BufferPoolingAllocate = (EventOpcode)12;
            public const EventOpcode StartWorkItemStartExecuteActivity = (EventOpcode)120;
            public const EventOpcode StartWorkItemStartFault = (EventOpcode)121;
            public const EventOpcode StartWorkItemStartRuntime = (EventOpcode)122;
            public const EventOpcode StartWorkItemStartTransactionContext = (EventOpcode)123;
            public const EventOpcode TrackingProfileNotFound = (EventOpcode)124;
            public const EventOpcode TrackingRecordDropped = (EventOpcode)125;
            public const EventOpcode TrackingRecordRaised = (EventOpcode)126;
            public const EventOpcode TrackingRecordTruncated = (EventOpcode)127;
            public const EventOpcode TransportReceiveBeforeAuthentication = (EventOpcode)128;
            public const EventOpcode TryCatchExceptionDuringCancelation = (EventOpcode)129;
            public const EventOpcode BufferPoolingTune = (EventOpcode)13;
            public const EventOpcode TryCatchExceptionFromCatchOrFinally = (EventOpcode)130;
            public const EventOpcode TryCatchExceptionFromTry = (EventOpcode)131;
            public const EventOpcode WASActivationConnected = (EventOpcode)132;
            public const EventOpcode WASActivationDisconnect = (EventOpcode)133;
            public const EventOpcode WFApplicationStateChangeCompleted = (EventOpcode)134;
            public const EventOpcode WFApplicationStateChangeIdled = (EventOpcode)135;
            public const EventOpcode WFApplicationStateChangeInstanceAborted = (EventOpcode)136;
            public const EventOpcode WFApplicationStateChangeInstanceCanceled = (EventOpcode)137;
            public const EventOpcode WFApplicationStateChangePersistableIdle = (EventOpcode)138;
            public const EventOpcode WFApplicationStateChangePersisted = (EventOpcode)139;
            public const EventOpcode ClientRuntimeClientChannelOpenStart = (EventOpcode)14;
            public const EventOpcode WFApplicationStateChangeTerminated = (EventOpcode)140;
            public const EventOpcode WFApplicationStateChangeUnhandledException = (EventOpcode)141;
            public const EventOpcode WFApplicationStateChangeUnloaded = (EventOpcode)142;
            public const EventOpcode WorkflowActivitysuspend = (EventOpcode)143;
            public const EventOpcode WorkflowInstanceRecordAbortedRecord = (EventOpcode)144;
            public const EventOpcode WorkflowInstanceRecordAbortedWithId = (EventOpcode)145;
            public const EventOpcode WorkflowInstanceRecordSuspendedRecord = (EventOpcode)146;
            public const EventOpcode WorkflowInstanceRecordSuspendedWithId = (EventOpcode)147;
            public const EventOpcode WorkflowInstanceRecordTerminatedRecord = (EventOpcode)148;
            public const EventOpcode WorkflowInstanceRecordTerminatedWithId = (EventOpcode)149;
            public const EventOpcode ClientRuntimeClientChannelOpenStop = (EventOpcode)15;
            public const EventOpcode WorkflowInstanceRecordUnhandledExceptionRecord = (EventOpcode)150;
            public const EventOpcode WorkflowInstanceRecordUnhandledExceptionWithId = (EventOpcode)151;
            public const EventOpcode WorkflowInstanceRecordUpdatedRecord = (EventOpcode)152;
            public const EventOpcode ClientRuntimeClientMessageInspectorAfterReceiveInvoked = (EventOpcode)16;
            public const EventOpcode ClientRuntimeClientMessageInspectorBeforeSendInvoked = (EventOpcode)17;
            public const EventOpcode ClientRuntimeClientParameterInspectorStart = (EventOpcode)18;
            public const EventOpcode ClientRuntimeClientParameterInspectorStop = (EventOpcode)19;
            public const EventOpcode ClientRuntimeOperationPrepared = (EventOpcode)20;
            public const EventOpcode CompleteWorkItemCompleteBookmark = (EventOpcode)21;
            public const EventOpcode CompleteWorkItemCompleteCancelActivity = (EventOpcode)22;
            public const EventOpcode CompleteWorkItemCompleteCompletion = (EventOpcode)23;
            public const EventOpcode CompleteWorkItemCompleteExecuteActivity = (EventOpcode)24;
            public const EventOpcode CompleteWorkItemCompleteFault = (EventOpcode)25;
            public const EventOpcode CompleteWorkItemCompleteRuntime = (EventOpcode)26;
            public const EventOpcode CompleteWorkItemCompleteTransactionContext = (EventOpcode)27;
            public const EventOpcode CorrelationDuplicateQuery = (EventOpcode)28;
            public const EventOpcode DiscoveryClientExceptionSuppressed = (EventOpcode)29;
            public const EventOpcode DiscoveryClientFailedToClose = (EventOpcode)30;
            public const EventOpcode DiscoveryClientReceivedMulticastSuppression = (EventOpcode)31;
            public const EventOpcode DiscoveryClientChannelCreationFailed = (EventOpcode)32;
            public const EventOpcode DiscoveryClientChannelFindInitiated = (EventOpcode)33;
            public const EventOpcode DiscoveryClientChannelOpenFailed = (EventOpcode)34;
            public const EventOpcode DiscoveryClientChannelOpenSucceeded = (EventOpcode)35;
            public const EventOpcode DiscoveryMessageDuplicate = (EventOpcode)36;
            public const EventOpcode DiscoveryMessageInvalidContent = (EventOpcode)37;
            public const EventOpcode DiscoveryMessageInvalidRelatesToOrOperationCompleted = (EventOpcode)38;
            public const EventOpcode DiscoveryMessageInvalidReplyTo = (EventOpcode)39;
            public const EventOpcode DiscoveryMessageNoContent = (EventOpcode)40;
            public const EventOpcode DiscoveryMessageNullMessageId = (EventOpcode)41;
            public const EventOpcode DiscoveryMessageNullMessageSequence = (EventOpcode)42;
            public const EventOpcode DiscoveryMessageNullRelatesTo = (EventOpcode)43;
            public const EventOpcode DiscoveryMessageNullReplyTo = (EventOpcode)44;
            public const EventOpcode DiscoveryMessageReceivedAfterOperationCompleted = (EventOpcode)45;
            public const EventOpcode DiscoverySynchronizationContextReset = (EventOpcode)46;
            public const EventOpcode DiscoverySynchronizationContextSetToNull = (EventOpcode)47;
            public const EventOpcode DispatchMessageBeforeAuthorization = (EventOpcode)48;
            public const EventOpcode DispatchMessageDispatchStart = (EventOpcode)49;
            public const EventOpcode DispatchMessageDispatchStop = (EventOpcode)50;
            public const EventOpcode DispatchMessageDispathMessageInspectorAfterReceiveInvoked = (EventOpcode)51;
            public const EventOpcode DispatchMessageDispathMessageInspectorBeforeSendInvoked = (EventOpcode)52;
            public const EventOpcode DispatchMessageOperationInvokerStart = (EventOpcode)53;
            public const EventOpcode DispatchMessageOperationInvokerStop = (EventOpcode)54;
            public const EventOpcode DispatchMessageParameterInspectorStart = (EventOpcode)55;
            public const EventOpcode DispatchMessageParameterInspectorStop = (EventOpcode)56;
            public const EventOpcode DispatchMessageTransactionScopeCreate = (EventOpcode)57;
            public const EventOpcode EndpointDiscoverabilityDisabled = (EventOpcode)58;
            public const EventOpcode EndpointDiscoverabilityEnabled = (EventOpcode)59;
            public const EventOpcode ExecuteFlowchartEmpty = (EventOpcode)60;
            public const EventOpcode ExecuteFlowchartNextNull = (EventOpcode)61;
            public const EventOpcode ExecuteFlowchartSwitchCase = (EventOpcode)62;
            public const EventOpcode ExecuteFlowchartSwitchCaseNotFound = (EventOpcode)63;
            public const EventOpcode ExecuteFlowchartSwitchDefault = (EventOpcode)64;
            public const EventOpcode InferDescriptionContract = (EventOpcode)69;
            public const EventOpcode InferDescriptionOperation = (EventOpcode)70;
            public const EventOpcode InvokeMethodDoesNotUseAsyncPattern = (EventOpcode)71;
            public const EventOpcode InvokeMethodIsNotStatic = (EventOpcode)72;
            public const EventOpcode InvokeMethodIsStatic = (EventOpcode)73;
            public const EventOpcode InvokeMethodThrewException = (EventOpcode)74;
            public const EventOpcode InvokeMethodUseAsyncPattern = (EventOpcode)75;
            public const EventOpcode MessageChannelCacheMissed = (EventOpcode)76;
            public const EventOpcode ReliableSessionFaulted = (EventOpcode)77;
            public const EventOpcode ReliableSessionReconnect = (EventOpcode)78;
            public const EventOpcode ReliableSessionSequenceAck = (EventOpcode)79;
            public const EventOpcode RoutingServiceAbortingChannel = (EventOpcode)80;
            public const EventOpcode RoutingServiceCloseFailed = (EventOpcode)81;
            public const EventOpcode RoutingServiceConfigurationApplied = (EventOpcode)82;
            public const EventOpcode RoutingServiceDuplexCallbackException = (EventOpcode)83;
            public const EventOpcode RoutingServiceHandledException = (EventOpcode)84;
            public const EventOpcode RoutingServiceTransmitFailed = (EventOpcode)85;
            public const EventOpcode RoutingServiceClientChannelFaulted = (EventOpcode)86;
            public const EventOpcode RoutingServiceClientClosing = (EventOpcode)87;
            public const EventOpcode RoutingServiceClientCreatingForEndpoint = (EventOpcode)88;
            public const EventOpcode RoutingServiceMessageCompletingOneWay = (EventOpcode)89;
            public const EventOpcode RoutingServiceMessageCompletingTwoWay = (EventOpcode)90;
            public const EventOpcode RoutingServiceMessageMovedToBackup = (EventOpcode)91;
            public const EventOpcode RoutingServiceMessageProcessingFailure = (EventOpcode)92;
            public const EventOpcode RoutingServiceMessageProcessingMessage = (EventOpcode)93;
            public const EventOpcode RoutingServiceMessageRoutedToEndpoints = (EventOpcode)94;
            public const EventOpcode RoutingServiceMessageSendingFaultResponse = (EventOpcode)95;
            public const EventOpcode RoutingServiceMessageSendingResponse = (EventOpcode)96;
            public const EventOpcode RoutingServiceMessageTransmitSucceeded = (EventOpcode)97;
            public const EventOpcode RoutingServiceMessageTransmittingMessage = (EventOpcode)98;
            public const EventOpcode RoutingServiceReceiveContextAbandoning = (EventOpcode)99;
        }
 
        public partial class Keywords
        {
            public const EventKeywords ServiceHost = (EventKeywords)0x1;
            public const EventKeywords Serialization = (EventKeywords)0x2;
            public const EventKeywords ServiceModel = (EventKeywords)0x4;
            public const EventKeywords Transaction = (EventKeywords)0x8;
            public const EventKeywords Security = (EventKeywords)0x10;
            public const EventKeywords WCFMessageLogging = (EventKeywords)0x20;
            public const EventKeywords WFTracking = (EventKeywords)0x40;
            public const EventKeywords WebHost = (EventKeywords)0x80;
            public const EventKeywords HTTP = (EventKeywords)0x100;
            public const EventKeywords TCP = (EventKeywords)0x200;
            public const EventKeywords TransportGeneral = (EventKeywords)0x400;
            public const EventKeywords ActivationServices = (EventKeywords)0x800;
            public const EventKeywords Channel = (EventKeywords)0x1000;
            public const EventKeywords WebHTTP = (EventKeywords)0x2000;
            public const EventKeywords Discovery = (EventKeywords)0x4000;
            public const EventKeywords RoutingServices = (EventKeywords)0x8000;
            public const EventKeywords Infrastructure = (EventKeywords)0x10000;
            public const EventKeywords EndToEndMonitoring = (EventKeywords)0x20000;
            public const EventKeywords HealthMonitoring = (EventKeywords)0x40000;
            public const EventKeywords Troubleshooting = (EventKeywords)0x80000;
            public const EventKeywords UserEvents = (EventKeywords)0x100000;
            public const EventKeywords Threading = (EventKeywords)0x200000;
            public const EventKeywords Quota = (EventKeywords)0x400000;
            public const EventKeywords WFRuntime = (EventKeywords)0x1000000;
            public const EventKeywords WFActivities = (EventKeywords)0x2000000;
            public const EventKeywords WFServices = (EventKeywords)0x4000000;
            public const EventKeywords WFInstanceStore = (EventKeywords)0x8000000;
        }
 
        public class ChannelKeywords
        {
            public const EventKeywords Admin = unchecked((EventKeywords)0x8000000000000000);
            public const EventKeywords Operational = unchecked((EventKeywords)0x4000000000000000);
            public const EventKeywords Analytic = unchecked((EventKeywords)0x2000000000000000);
            public const EventKeywords Debug = unchecked((EventKeywords)0x1000000000000000);
        }
        #endregion
    }
}