mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Diagnostics/TraceUtility.cs

   1 //----------------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 //----------------------------------------------------------------------------
   4 namespace System.ServiceModel.Diagnostics
   5 {
   6     using System.Diagnostics;
   7     using System.Reflection;
   8     using System.Runtime;
   9     using System.Runtime.CompilerServices;
  10     using System.Runtime.Diagnostics;
  11     using System.ServiceModel.Channels;
  12     using System.ServiceModel.Dispatcher;
  13     using System.Threading;
  14     using System.Security;
  15     using System.ServiceModel.Configuration;
  16     using System.ServiceModel.Activation;
  17     using System.Xml;
  18     using System.ServiceModel.Diagnostics.Application;
  19     using System.Globalization;
  20     using System.Collections.Generic;
  21
  22     static class TraceUtility
  23     {
  24         const string ActivityIdKey = "ActivityId";
  25         const string AsyncOperationActivityKey = "AsyncOperationActivity";
  26         const string AsyncOperationStartTimeKey = "AsyncOperationStartTime";
  27         static bool shouldPropagateActivity;
  28         static bool shouldPropagateActivityGlobal;
  29         static bool activityTracing;
  30         static bool messageFlowTracing;
  31         static bool messageFlowTracingOnly;
  32         static long messageNumber = 0;
  33         static Func<Action<AsyncCallback, IAsyncResult>> asyncCallbackGenerator;
  34         static SortedList<int, string> traceCodes = new SortedList<int, string>(382)
  35         {
  36             // Administration trace codes (TraceCode.Administration)
  37             { TraceCode.WmiPut, "WmiPut" },
  38
  39             // Diagnostic trace codes (TraceCode.Diagnostics)
  40             { TraceCode.AppDomainUnload, "AppDomainUnload" },
  41             { TraceCode.EventLog, "EventLog" },
  42             { TraceCode.ThrowingException, "ThrowingException" },
  43             { TraceCode.TraceHandledException, "TraceHandledException" },
  44             { TraceCode.UnhandledException, "UnhandledException" },
  45             { TraceCode.FailedToAddAnActivityIdHeader, "FailedToAddAnActivityIdHeader" },
  46             { TraceCode.FailedToReadAnActivityIdHeader, "FailedToReadAnActivityIdHeader" },
  47             { TraceCode.FilterNotMatchedNodeQuotaExceeded, "FilterNotMatchedNodeQuotaExceeded" },
  48             { TraceCode.MessageCountLimitExceeded, "MessageCountLimitExceeded" },
  49             { TraceCode.DiagnosticsFailedMessageTrace, "DiagnosticsFailedMessageTrace" },
  50             { TraceCode.MessageNotLoggedQuotaExceeded, "MessageNotLoggedQuotaExceeded" },
  51             { TraceCode.TraceTruncatedQuotaExceeded, "TraceTruncatedQuotaExceeded" },
  52             { TraceCode.ActivityBoundary, "ActivityBoundary" },
  53
  54             // Serialization trace codes (TraceCode.Serialization)
  55             { TraceCode.ElementIgnored, "" }, // shared by ServiceModel, need to investigate if should put this one in the SM section
  56
  57             // Channels trace codes (TraceCode.Channels)
  58             { TraceCode.ConnectionAbandoned, "ConnectionAbandoned" },
  59             { TraceCode.ConnectionPoolCloseException, "ConnectionPoolCloseException" },
  60             { TraceCode.ConnectionPoolIdleTimeoutReached, "ConnectionPoolIdleTimeoutReached" },
  61             { TraceCode.ConnectionPoolLeaseTimeoutReached, "ConnectionPoolLeaseTimeoutReached" },
  62             { TraceCode.ConnectionPoolMaxOutboundConnectionsPerEndpointQuotaReached, "ConnectionPoolMaxOutboundConnectionsPerEndpointQuotaReached" },
  63             { TraceCode.ServerMaxPooledConnectionsQuotaReached, "ServerMaxPooledConnectionsQuotaReached" },
  64             { TraceCode.EndpointListenerClose, "EndpointListenerClose" },
  65             { TraceCode.EndpointListenerOpen, "EndpointListenerOpen" },
  66             { TraceCode.HttpResponseReceived, "HttpResponseReceived" },
  67             { TraceCode.HttpChannelConcurrentReceiveQuotaReached, "HttpChannelConcurrentReceiveQuotaReached" },
  68             { TraceCode.HttpChannelMessageReceiveFailed, "HttpChannelMessageReceiveFailed" },
  69             { TraceCode.HttpChannelUnexpectedResponse, "HttpChannelUnexpectedResponse" },
  70             { TraceCode.HttpChannelRequestAborted, "HttpChannelRequestAborted" },
  71             { TraceCode.HttpChannelResponseAborted, "HttpChannelResponseAborted" },
  72             { TraceCode.HttpsClientCertificateInvalid, "HttpsClientCertificateInvalid" },
  73             { TraceCode.HttpsClientCertificateNotPresent, "HttpsClientCertificateNotPresent" },
  74             { TraceCode.NamedPipeChannelMessageReceiveFailed, "NamedPipeChannelMessageReceiveFailed" },
  75             { TraceCode.NamedPipeChannelMessageReceived, "NamedPipeChannelMessageReceived" },
  76             { TraceCode.MessageReceived, "MessageReceived" },
  77             { TraceCode.MessageSent, "MessageSent" },
  78             { TraceCode.RequestChannelReplyReceived, "RequestChannelReplyReceived" },
  79             { TraceCode.TcpChannelMessageReceiveFailed, "TcpChannelMessageReceiveFailed" },
  80             { TraceCode.TcpChannelMessageReceived, "TcpChannelMessageReceived" },
  81             { TraceCode.ConnectToIPEndpoint, "ConnectToIPEndpoint" },
  82             { TraceCode.SocketConnectionCreate, "SocketConnectionCreate" },
  83             { TraceCode.SocketConnectionClose, "SocketConnectionClose" },
  84             { TraceCode.SocketConnectionAbort, "SocketConnectionAbort" },
  85             { TraceCode.SocketConnectionAbortClose, "SocketConnectionAbortClose" },
  86             { TraceCode.PipeConnectionAbort, "PipeConnectionAbort" },
  87             { TraceCode.RequestContextAbort, "RequestContextAbort" },
  88             { TraceCode.ChannelCreated, "ChannelCreated" },
  89             { TraceCode.ChannelDisposed, "ChannelDisposed" },
  90             { TraceCode.ListenerCreated, "ListenerCreated" },
  91             { TraceCode.ListenerDisposed, "ListenerDisposed" },
  92             { TraceCode.PrematureDatagramEof, "PrematureDatagramEof" },
  93             { TraceCode.MaxPendingConnectionsReached, "MaxPendingConnectionsReached" },
  94             { TraceCode.MaxAcceptedChannelsReached, "MaxAcceptedChannelsReached" },
  95             { TraceCode.ChannelConnectionDropped, "ChannelConnectionDropped" },
  96             { TraceCode.HttpAuthFailed, "HttpAuthFailed" },
  97             { TraceCode.NoExistingTransportManager, "NoExistingTransportManager" },
  98             { TraceCode.IncompatibleExistingTransportManager, "IncompatibleExistingTransportManager" },
  99             { TraceCode.InitiatingNamedPipeConnection, "InitiatingNamedPipeConnection" },
 100             { TraceCode.InitiatingTcpConnection, "InitiatingTcpConnection" },
 101             { TraceCode.OpenedListener, "OpenedListener" },
 102             { TraceCode.SslClientCertMissing, "SslClientCertMissing" },
 103             { TraceCode.StreamSecurityUpgradeAccepted, "StreamSecurityUpgradeAccepted" },
 104             { TraceCode.TcpConnectError, "TcpConnectError" },
 105             { TraceCode.FailedAcceptFromPool, "FailedAcceptFromPool" },
 106             { TraceCode.FailedPipeConnect, "FailedPipeConnect" },
 107             { TraceCode.SystemTimeResolution, "SystemTimeResolution" },
 108             { TraceCode.PeerNeighborCloseFailed, "PeerNeighborCloseFailed" },
 109             { TraceCode.PeerNeighborClosingFailed, "PeerNeighborClosingFailed" },
 110             { TraceCode.PeerNeighborNotAccepted, "PeerNeighborNotAccepted" },
 111             { TraceCode.PeerNeighborNotFound, "PeerNeighborNotFound" },
 112             { TraceCode.PeerNeighborOpenFailed, "PeerNeighborOpenFailed" },
 113             { TraceCode.PeerNeighborStateChanged, "PeerNeighborStateChanged" },
 114             { TraceCode.PeerNeighborStateChangeFailed, "PeerNeighborStateChangeFailed" },
 115             { TraceCode.PeerNeighborMessageReceived, "PeerNeighborMessageReceived" },
 116             { TraceCode.PeerNeighborManagerOffline, "PeerNeighborManagerOffline" },
 117             { TraceCode.PeerNeighborManagerOnline, "PeerNeighborManagerOnline" },
 118             { TraceCode.PeerChannelMessageReceived, "PeerChannelMessageReceived" },
 119             { TraceCode.PeerChannelMessageSent, "PeerChannelMessageSent" },
 120             { TraceCode.PeerNodeAddressChanged, "PeerNodeAddressChanged" },
 121             { TraceCode.PeerNodeOpening, "PeerNodeOpening" },
 122             { TraceCode.PeerNodeOpened, "PeerNodeOpened" },
 123             { TraceCode.PeerNodeOpenFailed, "PeerNodeOpenFailed" },
 124             { TraceCode.PeerNodeClosing, "PeerNodeClosing" },
 125             { TraceCode.PeerNodeClosed, "PeerNodeClosed" },
 126             { TraceCode.PeerFloodedMessageReceived, "PeerFloodedMessageReceived" },
 127             { TraceCode.PeerFloodedMessageNotPropagated, "PeerFloodedMessageNotPropagated" },
 128             { TraceCode.PeerFloodedMessageNotMatched, "PeerFloodedMessageNotMatched" },
 129             { TraceCode.PnrpRegisteredAddresses, "PnrpRegisteredAddresses" },
 130             { TraceCode.PnrpUnregisteredAddresses, "PnrpUnregisteredAddresses" },
 131             { TraceCode.PnrpResolvedAddresses, "PnrpResolvedAddresses" },
 132             { TraceCode.PnrpResolveException, "PnrpResolveException" },
 133             { TraceCode.PeerReceiveMessageAuthenticationFailure, "PeerReceiveMessageAuthenticationFailure" },
 134             { TraceCode.PeerNodeAuthenticationFailure, "PeerNodeAuthenticationFailure" },
 135             { TraceCode.PeerNodeAuthenticationTimeout, "PeerNodeAuthenticationTimeout" },
 136             { TraceCode.PeerFlooderReceiveMessageQuotaExceeded, "PeerFlooderReceiveMessageQuotaExceeded" },
 137             { TraceCode.PeerServiceOpened, "PeerServiceOpened" },
 138             { TraceCode.PeerMaintainerActivity, "PeerMaintainerActivity" },
 139             { TraceCode.MsmqCannotPeekOnQueue, "MsmqCannotPeekOnQueue" },
 140             { TraceCode.MsmqCannotReadQueues, "MsmqCannotReadQueues" },
 141             { TraceCode.MsmqDatagramSent, "MsmqDatagramSent" },
 142             { TraceCode.MsmqDatagramReceived, "MsmqDatagramReceived" },
 143             { TraceCode.MsmqDetected, "MsmqDetected" },
 144             { TraceCode.MsmqEnteredBatch, "MsmqEnteredBatch" },
 145             { TraceCode.MsmqExpectedException, "MsmqExpectedException" },
 146             { TraceCode.MsmqFoundBaseAddress, "MsmqFoundBaseAddress" },
 147             { TraceCode.MsmqLeftBatch, "MsmqLeftBatch" },
 148             { TraceCode.MsmqMatchedApplicationFound, "MsmqMatchedApplicationFound" },
 149             { TraceCode.MsmqMessageDropped, "MsmqMessageDropped" },
 150             { TraceCode.MsmqMessageLockedUnderTheTransaction, "MsmqMessageLockedUnderTheTransaction" },
 151             { TraceCode.MsmqMessageRejected, "MsmqMessageRejected" },
 152             { TraceCode.MsmqMoveOrDeleteAttemptFailed, "MsmqMoveOrDeleteAttemptFailed" },
 153             { TraceCode.MsmqPoisonMessageMovedPoison, "MsmqPoisonMessageMovedPoison" },
 154             { TraceCode.MsmqPoisonMessageMovedRetry, "MsmqPoisonMessageMovedRetry" },
 155             { TraceCode.MsmqPoisonMessageRejected, "MsmqPoisonMessageRejected" },
 156             { TraceCode.MsmqPoolFull, "MsmqPoolFull" },
 157             { TraceCode.MsmqPotentiallyPoisonMessageDetected, "MsmqPotentiallyPoisonMessageDetected" },
 158             { TraceCode.MsmqQueueClosed, "MsmqQueueClosed" },
 159             { TraceCode.MsmqQueueOpened, "MsmqQueueOpened" },
 160             { TraceCode.MsmqQueueTransactionalStatusUnknown, "MsmqQueueTransactionalStatusUnknown" },
 161             { TraceCode.MsmqScanStarted, "MsmqScanStarted" },
 162             { TraceCode.MsmqSessiongramReceived, "MsmqSessiongramReceived" },
 163             { TraceCode.MsmqSessiongramSent, "MsmqSessiongramSent" },
 164             { TraceCode.MsmqStartingApplication, "MsmqStartingApplication" },
 165             { TraceCode.MsmqStartingService, "MsmqStartingService" },
 166             { TraceCode.MsmqUnexpectedAcknowledgment, "MsmqUnexpectedAcknowledgment" },
 167             { TraceCode.WsrmNegativeElapsedTimeDetected, "WsrmNegativeElapsedTimeDetected" },
 168             { TraceCode.TcpTransferError, "TcpTransferError" },
 169             { TraceCode.TcpConnectionResetError, "TcpConnectionResetError" },
 170             { TraceCode.TcpConnectionTimedOut, "TcpConnectionTimedOut" },
 171
 172             // ComIntegration trace codes (TraceCode.ComIntegration)
 173             { TraceCode.ComIntegrationServiceHostStartingService, "ComIntegrationServiceHostStartingService" },
 174             { TraceCode.ComIntegrationServiceHostStartedService, "ComIntegrationServiceHostStartedService" },
 175             { TraceCode.ComIntegrationServiceHostCreatedServiceContract, "ComIntegrationServiceHostCreatedServiceContract" },
 176             { TraceCode.ComIntegrationServiceHostStartedServiceDetails, "ComIntegrationServiceHostStartedServiceDetails" },
 177             { TraceCode.ComIntegrationServiceHostCreatedServiceEndpoint, "ComIntegrationServiceHostCreatedServiceEndpoint" },
 178             { TraceCode.ComIntegrationServiceHostStoppingService, "ComIntegrationServiceHostStoppingService" },
 179             { TraceCode.ComIntegrationServiceHostStoppedService, "ComIntegrationServiceHostStoppedService" },
 180             { TraceCode.ComIntegrationDllHostInitializerStarting, "ComIntegrationDllHostInitializerStarting" },
 181             { TraceCode.ComIntegrationDllHostInitializerAddingHost, "ComIntegrationDllHostInitializerAddingHost" },
 182             { TraceCode.ComIntegrationDllHostInitializerStarted, "ComIntegrationDllHostInitializerStarted" },
 183             { TraceCode.ComIntegrationDllHostInitializerStopping, "ComIntegrationDllHostInitializerStopping" },
 184             { TraceCode.ComIntegrationDllHostInitializerStopped, "ComIntegrationDllHostInitializerStopped" },
 185             { TraceCode.ComIntegrationTLBImportStarting, "ComIntegrationTLBImportStarting" },
 186             { TraceCode.ComIntegrationTLBImportFromAssembly, "ComIntegrationTLBImportFromAssembly" },
 187             { TraceCode.ComIntegrationTLBImportFromTypelib, "ComIntegrationTLBImportFromTypelib" },
 188             { TraceCode.ComIntegrationTLBImportConverterEvent, "ComIntegrationTLBImportConverterEvent" },
 189             { TraceCode.ComIntegrationTLBImportFinished, "ComIntegrationTLBImportFinished" },
 190             { TraceCode.ComIntegrationInstanceCreationRequest, "ComIntegrationInstanceCreationRequest" },
 191             { TraceCode.ComIntegrationInstanceCreationSuccess, "ComIntegrationInstanceCreationSuccess" },
 192             { TraceCode.ComIntegrationInstanceReleased, "ComIntegrationInstanceReleased" },
 193             { TraceCode.ComIntegrationEnteringActivity, "ComIntegrationEnteringActivity" },
 194             { TraceCode.ComIntegrationExecutingCall, "ComIntegrationExecutingCall" },
 195             { TraceCode.ComIntegrationLeftActivity, "ComIntegrationLeftActivity" },
 196             { TraceCode.ComIntegrationInvokingMethod, "ComIntegrationInvokingMethod" },
 197             { TraceCode.ComIntegrationInvokedMethod, "ComIntegrationInvokedMethod" },
 198             { TraceCode.ComIntegrationInvokingMethodNewTransaction, "ComIntegrationInvokingMethodNewTransaction" },
 199             { TraceCode.ComIntegrationInvokingMethodContextTransaction, "ComIntegrationInvokingMethodContextTransaction" },
 200             { TraceCode.ComIntegrationServiceMonikerParsed, "ComIntegrationServiceMonikerParsed" },
 201             { TraceCode.ComIntegrationWsdlChannelBuilderLoaded, "ComIntegrationWsdlChannelBuilderLoaded" },
 202             { TraceCode.ComIntegrationTypedChannelBuilderLoaded, "ComIntegrationTypedChannelBuilderLoaded" },
 203             { TraceCode.ComIntegrationChannelCreated, "ComIntegrationChannelCreated" },
 204             { TraceCode.ComIntegrationDispatchMethod, "ComIntegrationDispatchMethod" },
 205             { TraceCode.ComIntegrationTxProxyTxCommitted, "ComIntegrationTxProxyTxCommitted" },
 206             { TraceCode.ComIntegrationTxProxyTxAbortedByContext, "ComIntegrationTxProxyTxAbortedByContext" },
 207             { TraceCode.ComIntegrationTxProxyTxAbortedByTM, "ComIntegrationTxProxyTxAbortedByTM" },
 208             { TraceCode.ComIntegrationMexMonikerMetadataExchangeComplete, "ComIntegrationMexMonikerMetadataExchangeComplete" },
 209             { TraceCode.ComIntegrationMexChannelBuilderLoaded, "ComIntegrationMexChannelBuilderLoaded" },
 210
 211             // Security trace codes (TraceCode.Security)
 212             { TraceCode.Security, "Security" },
 213             { TraceCode.SecurityIdentityVerificationSuccess, "SecurityIdentityVerificationSuccess" },
 214             { TraceCode.SecurityIdentityVerificationFailure, "SecurityIdentityVerificationFailure" },
 215             { TraceCode.SecurityIdentityDeterminationSuccess, "SecurityIdentityDeterminationSuccess" },
 216             { TraceCode.SecurityIdentityDeterminationFailure, "SecurityIdentityDeterminationFailure" },
 217             { TraceCode.SecurityIdentityHostNameNormalizationFailure, "SecurityIdentityHostNameNormalizationFailure" },
 218             { TraceCode.SecurityImpersonationSuccess, "SecurityImpersonationSuccess" },
 219             { TraceCode.SecurityImpersonationFailure, "SecurityImpersonationFailure" },
 220             { TraceCode.SecurityNegotiationProcessingFailure, "SecurityNegotiationProcessingFailure" },
 221             { TraceCode.IssuanceTokenProviderRemovedCachedToken, "IssuanceTokenProviderRemovedCachedToken" },
 222             { TraceCode.IssuanceTokenProviderUsingCachedToken, "IssuanceTokenProviderUsingCachedToken" },
 223             { TraceCode.IssuanceTokenProviderBeginSecurityNegotiation, "IssuanceTokenProviderBeginSecurityNegotiation" },
 224             { TraceCode.IssuanceTokenProviderEndSecurityNegotiation, "IssuanceTokenProviderEndSecurityNegotiation" },
 225             { TraceCode.IssuanceTokenProviderRedirectApplied, "IssuanceTokenProviderRedirectApplied" },
 226             { TraceCode.IssuanceTokenProviderServiceTokenCacheFull, "IssuanceTokenProviderServiceTokenCacheFull" },
 227             { TraceCode.NegotiationTokenProviderAttached, "NegotiationTokenProviderAttached" },
 228             { TraceCode.SpnegoClientNegotiationCompleted, "SpnegoClientNegotiationCompleted" },
 229             { TraceCode.SpnegoServiceNegotiationCompleted, "SpnegoServiceNegotiationCompleted" },
 230             { TraceCode.SpnegoClientNegotiation, "SpnegoClientNegotiation" },
 231             { TraceCode.SpnegoServiceNegotiation, "SpnegoServiceNegotiation" },
 232             { TraceCode.NegotiationAuthenticatorAttached, "NegotiationAuthenticatorAttached" },
 233             { TraceCode.ServiceSecurityNegotiationCompleted, "ServiceSecurityNegotiationCompleted" },
 234             { TraceCode.SecurityContextTokenCacheFull, "SecurityContextTokenCacheFull" },
 235             { TraceCode.ExportSecurityChannelBindingEntry, "ExportSecurityChannelBindingEntry" },
 236             { TraceCode.ExportSecurityChannelBindingExit, "ExportSecurityChannelBindingExit" },
 237             { TraceCode.ImportSecurityChannelBindingEntry, "ImportSecurityChannelBindingEntry" },
 238             { TraceCode.ImportSecurityChannelBindingExit, "ImportSecurityChannelBindingExit" },
 239             { TraceCode.SecurityTokenProviderOpened, "SecurityTokenProviderOpened" },
 240             { TraceCode.SecurityTokenProviderClosed, "SecurityTokenProviderClosed" },
 241             { TraceCode.SecurityTokenAuthenticatorOpened, "SecurityTokenAuthenticatorOpened" },
 242             { TraceCode.SecurityTokenAuthenticatorClosed, "SecurityTokenAuthenticatorClosed" },
 243             { TraceCode.SecurityBindingOutgoingMessageSecured, "SecurityBindingOutgoingMessageSecured" },
 244             { TraceCode.SecurityBindingIncomingMessageVerified, "SecurityBindingIncomingMessageVerified" },
 245             { TraceCode.SecurityBindingSecureOutgoingMessageFailure, "SecurityBindingSecureOutgoingMessageFailure" },
 246             { TraceCode.SecurityBindingVerifyIncomingMessageFailure, "SecurityBindingVerifyIncomingMessageFailure" },
 247             { TraceCode.SecuritySpnToSidMappingFailure, "SecuritySpnToSidMappingFailure" },
 248             { TraceCode.SecuritySessionRedirectApplied, "SecuritySessionRedirectApplied" },
 249             { TraceCode.SecurityClientSessionCloseSent, "SecurityClientSessionCloseSent" },
 250             { TraceCode.SecurityClientSessionCloseResponseSent, "SecurityClientSessionCloseResponseSent" },
 251             { TraceCode.SecurityClientSessionCloseMessageReceived, "SecurityClientSessionCloseMessageReceived" },
 252             { TraceCode.SecuritySessionKeyRenewalFaultReceived, "SecuritySessionKeyRenewalFaultReceived" },
 253             { TraceCode.SecuritySessionAbortedFaultReceived, "SecuritySessionAbortedFaultReceived" },
 254             { TraceCode.SecuritySessionClosedResponseReceived, "SecuritySessionClosedResponseReceived" },
 255             { TraceCode.SecurityClientSessionPreviousKeyDiscarded, "SecurityClientSessionPreviousKeyDiscarded" },
 256             { TraceCode.SecurityClientSessionKeyRenewed, "SecurityClientSessionKeyRenewed" },
 257             { TraceCode.SecurityPendingServerSessionAdded, "SecurityPendingServerSessionAdded" },
 258             { TraceCode.SecurityPendingServerSessionClosed, "SecurityPendingServerSessionClosed" },
 259             { TraceCode.SecurityPendingServerSessionActivated, "SecurityPendingServerSessionActivated" },
 260             { TraceCode.SecurityActiveServerSessionRemoved, "SecurityActiveServerSessionRemoved" },
 261             { TraceCode.SecurityNewServerSessionKeyIssued, "SecurityNewServerSessionKeyIssued" },
 262             { TraceCode.SecurityInactiveSessionFaulted, "SecurityInactiveSessionFaulted" },
 263             { TraceCode.SecurityServerSessionKeyUpdated, "SecurityServerSessionKeyUpdated" },
 264             { TraceCode.SecurityServerSessionCloseReceived, "SecurityServerSessionCloseReceived" },
 265             { TraceCode.SecurityServerSessionRenewalFaultSent, "SecurityServerSessionRenewalFaultSent" },
 266             { TraceCode.SecurityServerSessionAbortedFaultSent, "SecurityServerSessionAbortedFaultSent" },
 267             { TraceCode.SecuritySessionCloseResponseSent, "SecuritySessionCloseResponseSent" },
 268             { TraceCode.SecuritySessionServerCloseSent, "SecuritySessionServerCloseSent" },
 269             { TraceCode.SecurityServerSessionCloseResponseReceived, "SecurityServerSessionCloseResponseReceived" },
 270             { TraceCode.SecuritySessionRenewFaultSendFailure, "SecuritySessionRenewFaultSendFailure" },
 271             { TraceCode.SecuritySessionAbortedFaultSendFailure, "SecuritySessionAbortedFaultSendFailure" },
 272             { TraceCode.SecuritySessionClosedResponseSendFailure, "SecuritySessionClosedResponseSendFailure" },
 273             { TraceCode.SecuritySessionServerCloseSendFailure, "SecuritySessionServerCloseSendFailure" },
 274             { TraceCode.SecuritySessionRequestorStartOperation, "SecuritySessionRequestorStartOperation" },
 275             { TraceCode.SecuritySessionRequestorOperationSuccess, "SecuritySessionRequestorOperationSuccess" },
 276             { TraceCode.SecuritySessionRequestorOperationFailure, "SecuritySessionRequestorOperationFailure" },
 277             { TraceCode.SecuritySessionResponderOperationFailure, "SecuritySessionResponderOperationFailure" },
 278             { TraceCode.SecuritySessionDemuxFailure, "SecuritySessionDemuxFailure" },
 279             { TraceCode.SecurityAuditWrittenSuccess, "SecurityAuditWrittenSuccess" },
 280             { TraceCode.SecurityAuditWrittenFailure, "SecurityAuditWrittenFailure" },
 281
 282             // ServiceModel trace codes (TraceCode.ServiceModel)
 283             { TraceCode.AsyncCallbackThrewException, "AsyncCallbackThrewException" },
 284             { TraceCode.CommunicationObjectAborted, "CommunicationObjectAborted" },
 285             { TraceCode.CommunicationObjectAbortFailed, "CommunicationObjectAbortFailed" },
 286             { TraceCode.CommunicationObjectCloseFailed, "CommunicationObjectCloseFailed" },
 287             { TraceCode.CommunicationObjectOpenFailed, "CommunicationObjectOpenFailed" },
 288             { TraceCode.CommunicationObjectClosing, "CommunicationObjectClosing" },
 289             { TraceCode.CommunicationObjectClosed, "CommunicationObjectClosed" },
 290             { TraceCode.CommunicationObjectCreated, "CommunicationObjectCreated" },
 291             { TraceCode.CommunicationObjectDisposing, "CommunicationObjectDisposing" },
 292             { TraceCode.CommunicationObjectFaultReason, "CommunicationObjectFaultReason" },
 293             { TraceCode.CommunicationObjectFaulted, "CommunicationObjectFaulted" },
 294             { TraceCode.CommunicationObjectOpening, "CommunicationObjectOpening" },
 295             { TraceCode.CommunicationObjectOpened, "CommunicationObjectOpened" },
 296             { TraceCode.DidNotUnderstandMessageHeader, "DidNotUnderstandMessageHeader" },
 297             { TraceCode.UnderstoodMessageHeader, "UnderstoodMessageHeader" },
 298             { TraceCode.MessageClosed, "MessageClosed" },
 299             { TraceCode.MessageClosedAgain, "MessageClosedAgain" },
 300             { TraceCode.MessageCopied, "MessageCopied" },
 301             { TraceCode.MessageRead, "MessageRead" },
 302             { TraceCode.MessageWritten, "MessageWritten" },
 303             { TraceCode.BeginExecuteMethod, "BeginExecuteMethod" },
 304             { TraceCode.ConfigurationIsReadOnly, "ConfigurationIsReadOnly" },
 305             { TraceCode.ConfiguredExtensionTypeNotFound, "ConfiguredExtensionTypeNotFound" },
 306             { TraceCode.EvaluationContextNotFound, "EvaluationContextNotFound" },
 307             { TraceCode.EndExecuteMethod, "EndExecuteMethod" },
 308             { TraceCode.ExtensionCollectionDoesNotExist, "ExtensionCollectionDoesNotExist" },
 309             { TraceCode.ExtensionCollectionNameNotFound, "ExtensionCollectionNameNotFound" },
 310             { TraceCode.ExtensionCollectionIsEmpty, "ExtensionCollectionIsEmpty" },
 311             { TraceCode.ExtensionElementAlreadyExistsInCollection, "ExtensionElementAlreadyExistsInCollection" },
 312             { TraceCode.ElementTypeDoesntMatchConfiguredType, "ElementTypeDoesntMatchConfiguredType" },
 313             { TraceCode.ErrorInvokingUserCode, "ErrorInvokingUserCode" },
 314             { TraceCode.GetBehaviorElement, "GetBehaviorElement" },
 315             { TraceCode.GetCommonBehaviors, "GetCommonBehaviors" },
 316             { TraceCode.GetConfiguredBinding, "GetConfiguredBinding" },
 317             { TraceCode.GetChannelEndpointElement, "GetChannelEndpointElement" },
 318             { TraceCode.GetConfigurationSection, "GetConfigurationSection" },
 319             { TraceCode.GetDefaultConfiguredBinding, "GetDefaultConfiguredBinding" },
 320             { TraceCode.GetServiceElement, "GetServiceElement" },
 321             { TraceCode.MessageProcessingPaused, "MessageProcessingPaused" },
 322             { TraceCode.ManualFlowThrottleLimitReached, "ManualFlowThrottleLimitReached" },
 323             { TraceCode.OverridingDuplicateConfigurationKey, "OverridingDuplicateConfigurationKey" },
 324             { TraceCode.RemoveBehavior, "RemoveBehavior" },
 325             { TraceCode.ServiceChannelLifetime, "ServiceChannelLifetime" },
 326             { TraceCode.ServiceHostCreation, "ServiceHostCreation" },
 327             { TraceCode.ServiceHostBaseAddresses, "ServiceHostBaseAddresses" },
 328             { TraceCode.ServiceHostTimeoutOnClose, "ServiceHostTimeoutOnClose" },
 329             { TraceCode.ServiceHostFaulted, "ServiceHostFaulted" },
 330             { TraceCode.ServiceHostErrorOnReleasePerformanceCounter, "ServiceHostErrorOnReleasePerformanceCounter" },
 331             { TraceCode.ServiceThrottleLimitReached, "ServiceThrottleLimitReached" },
 332             { TraceCode.ServiceOperationMissingReply, "ServiceOperationMissingReply" },
 333             { TraceCode.ServiceOperationMissingReplyContext, "ServiceOperationMissingReplyContext" },
 334             { TraceCode.ServiceOperationExceptionOnReply, "ServiceOperationExceptionOnReply" },
 335             { TraceCode.SkipBehavior, "SkipBehavior" },
 336             { TraceCode.TransportListen, "TransportListen" },
 337             { TraceCode.UnhandledAction, "UnhandledAction" },
 338             { TraceCode.PerformanceCounterFailedToLoad, "PerformanceCounterFailedToLoad" },
 339             { TraceCode.PerformanceCountersFailed, "PerformanceCountersFailed" },
 340             { TraceCode.PerformanceCountersFailedDuringUpdate, "PerformanceCountersFailedDuringUpdate" },
 341             { TraceCode.PerformanceCountersFailedForService, "PerformanceCountersFailedForService" },
 342             { TraceCode.PerformanceCountersFailedOnRelease, "PerformanceCountersFailedOnRelease" },
 343             { TraceCode.WsmexNonCriticalWsdlExportError, "WsmexNonCriticalWsdlExportError" },
 344             { TraceCode.WsmexNonCriticalWsdlImportError, "WsmexNonCriticalWsdlImportError" },
 345             { TraceCode.FailedToOpenIncomingChannel, "FailedToOpenIncomingChannel" },
 346             { TraceCode.UnhandledExceptionInUserOperation, "UnhandledExceptionInUserOperation" },
 347             { TraceCode.DroppedAMessage, "DroppedAMessage" },
 348             { TraceCode.CannotBeImportedInCurrentFormat, "CannotBeImportedInCurrentFormat" },
 349             { TraceCode.GetConfiguredEndpoint, "GetConfiguredEndpoint" },
 350             { TraceCode.GetDefaultConfiguredEndpoint, "GetDefaultConfiguredEndpoint" },
 351             { TraceCode.ExtensionTypeNotFound, "ExtensionTypeNotFound" },
 352             { TraceCode.DefaultEndpointsAdded, "DefaultEndpointsAdded" },
 353
 354             //ServiceModel Metadata codes
 355             { TraceCode.MetadataExchangeClientSendRequest, "MetadataExchangeClientSendRequest" },
 356             { TraceCode.MetadataExchangeClientReceiveReply, "MetadataExchangeClientReceiveReply" },
 357             { TraceCode.WarnHelpPageEnabledNoBaseAddress, "WarnHelpPageEnabledNoBaseAddress" },
 358
 359             // PortSharingtrace codes (TraceCode.PortSharing)
 360             { TraceCode.PortSharingClosed, "PortSharingClosed" },
 361             { TraceCode.PortSharingDuplicatedPipe, "PortSharingDuplicatedPipe" },
 362             { TraceCode.PortSharingDupHandleGranted, "PortSharingDupHandleGranted" },
 363             { TraceCode.PortSharingDuplicatedSocket, "PortSharingDuplicatedSocket" },
 364             { TraceCode.PortSharingListening, "PortSharingListening" },
 365             { TraceCode.SharedManagerServiceEndpointNotExist, "SharedManagerServiceEndpointNotExist" },
 366
 367             //Indigo Tx trace codes (TraceCode.ServiceModelTransaction)
 368             { TraceCode.TxSourceTxScopeRequiredIsTransactedTransport, "TxSourceTxScopeRequiredIsTransactedTransport" },
 369             { TraceCode.TxSourceTxScopeRequiredIsTransactionFlow, "TxSourceTxScopeRequiredIsTransactionFlow" },
 370             { TraceCode.TxSourceTxScopeRequiredIsAttachedTransaction, "TxSourceTxScopeRequiredIsAttachedTransaction" },
 371             { TraceCode.TxSourceTxScopeRequiredIsCreateNewTransaction, "TxSourceTxScopeRequiredIsCreateNewTransaction" },
 372             { TraceCode.TxCompletionStatusCompletedForAutocomplete, "TxCompletionStatusCompletedForAutocomplete" },
 373             { TraceCode.TxCompletionStatusCompletedForError, "TxCompletionStatusCompletedForError" },
 374             { TraceCode.TxCompletionStatusCompletedForSetComplete, "TxCompletionStatusCompletedForSetComplete" },
 375             { TraceCode.TxCompletionStatusCompletedForTACOSC, "TxCompletionStatusCompletedForTACOSC" },
 376             { TraceCode.TxCompletionStatusCompletedForAsyncAbort, "TxCompletionStatusCompletedForAsyncAbort" },
 377             { TraceCode.TxCompletionStatusRemainsAttached, "TxCompletionStatusRemainsAttached" },
 378             { TraceCode.TxCompletionStatusAbortedOnSessionClose, "TxCompletionStatusAbortedOnSessionClose" },
 379             { TraceCode.TxReleaseServiceInstanceOnCompletion, "TxReleaseServiceInstanceOnCompletion" },
 380             { TraceCode.TxAsyncAbort, "TxAsyncAbort" },
 381             { TraceCode.TxFailedToNegotiateOleTx, "TxFailedToNegotiateOleTx" },
 382             { TraceCode.TxSourceTxScopeRequiredUsingExistingTransaction, "TxSourceTxScopeRequiredUsingExistingTransaction" },
 383
 384             //CfxGreen trace codes (TraceCode.NetFx35)
 385             { TraceCode.ActivatingMessageReceived, "ActivatingMessageReceived" },
 386             { TraceCode.InstanceContextBoundToDurableInstance, "InstanceContextBoundToDurableInstance" },
 387             { TraceCode.InstanceContextDetachedFromDurableInstance, "InstanceContextDetachedFromDurableInstance" },
 388             { TraceCode.ContextChannelFactoryChannelCreated, "ContextChannelFactoryChannelCreated" },
 389             { TraceCode.ContextChannelListenerChannelAccepted, "ContextChannelListenerChannelAccepted" },
 390             { TraceCode.ContextProtocolContextAddedToMessage, "ContextProtocolContextAddedToMessage" },
 391             { TraceCode.ContextProtocolContextRetrievedFromMessage, "ContextProtocolContextRetrievedFromMessage" },
 392             { TraceCode.DICPInstanceContextCached, "DICPInstanceContextCached" },
 393             { TraceCode.DICPInstanceContextRemovedFromCache, "DICPInstanceContextRemovedFromCache" },
 394             { TraceCode.ServiceDurableInstanceDeleted, "ServiceDurableInstanceDeleted" },
 395             { TraceCode.ServiceDurableInstanceDisposed, "ServiceDurableInstanceDisposed" },
 396             { TraceCode.ServiceDurableInstanceLoaded, "ServiceDurableInstanceLoaded" },
 397             { TraceCode.ServiceDurableInstanceSaved, "ServiceDurableInstanceSaved" },
 398             { TraceCode.SqlPersistenceProviderSQLCallStart, "SqlPersistenceProviderSQLCallStart" },
 399             { TraceCode.SqlPersistenceProviderSQLCallEnd, "SqlPersistenceProviderSQLCallEnd" },
 400             { TraceCode.SqlPersistenceProviderOpenParameters, "SqlPersistenceProviderOpenParameters" },
 401             { TraceCode.SyncContextSchedulerServiceTimerCancelled, "SyncContextSchedulerServiceTimerCancelled" },
 402             { TraceCode.SyncContextSchedulerServiceTimerCreated, "SyncContextSchedulerServiceTimerCreated" },
 403             { TraceCode.WorkflowDurableInstanceLoaded, "WorkflowDurableInstanceLoaded" },
 404             { TraceCode.WorkflowDurableInstanceAborted, "WorkflowDurableInstanceAborted" },
 405             { TraceCode.WorkflowDurableInstanceActivated, "WorkflowDurableInstanceActivated" },
 406             { TraceCode.WorkflowOperationInvokerItemQueued, "WorkflowOperationInvokerItemQueued" },
 407             { TraceCode.WorkflowRequestContextReplySent, "WorkflowRequestContextReplySent" },
 408             { TraceCode.WorkflowRequestContextFaultSent, "WorkflowRequestContextFaultSent" },
 409             { TraceCode.WorkflowServiceHostCreated, "WorkflowServiceHostCreated" },
 410             { TraceCode.SyndicationReadFeedBegin, "SyndicationReadFeedBegin" },
 411             { TraceCode.SyndicationReadFeedEnd, "SyndicationReadFeedEnd" },
 412             { TraceCode.SyndicationReadItemBegin, "SyndicationReadItemBegin" },
 413             { TraceCode.SyndicationReadItemEnd, "SyndicationReadItemEnd" },
 414             { TraceCode.SyndicationWriteFeedBegin, "SyndicationWriteFeedBegin" },
 415             { TraceCode.SyndicationWriteFeedEnd, "SyndicationWriteFeedEnd" },
 416             { TraceCode.SyndicationWriteItemBegin, "SyndicationWriteItemBegin" },
 417             { TraceCode.SyndicationWriteItemEnd, "SyndicationWriteItemEnd" },
 418             { TraceCode.SyndicationProtocolElementIgnoredOnRead, "SyndicationProtocolElementIgnoredOnRead" },
 419             { TraceCode.SyndicationProtocolElementIgnoredOnWrite, "SyndicationProtocolElementIgnoredOnWrite" },
 420             { TraceCode.SyndicationProtocolElementInvalid, "SyndicationProtocolElementInvalid" },
 421             { TraceCode.WebUnknownQueryParameterIgnored, "WebUnknownQueryParameterIgnored" },
 422             { TraceCode.WebRequestMatchesOperation, "WebRequestMatchesOperation" },
 423             { TraceCode.WebRequestDoesNotMatchOperations, "WebRequestDoesNotMatchOperations" },
 424             { TraceCode.WebRequestRedirect, "WebRequestRedirect" },
 425             { TraceCode.SyndicationReadServiceDocumentBegin, "SyndicationReadServiceDocumentBegin" },
 426             { TraceCode.SyndicationReadServiceDocumentEnd, "SyndicationReadServiceDocumentEnd" },
 427             { TraceCode.SyndicationReadCategoriesDocumentBegin, "SyndicationReadCategoriesDocumentBegin" },
 428             { TraceCode.SyndicationReadCategoriesDocumentEnd, "SyndicationReadCategoriesDocumentEnd" },
 429             { TraceCode.SyndicationWriteServiceDocumentBegin, "SyndicationWriteServiceDocumentBegin" },
 430             { TraceCode.SyndicationWriteServiceDocumentEnd, "SyndicationWriteServiceDocumentEnd" },
 431             { TraceCode.SyndicationWriteCategoriesDocumentBegin, "SyndicationWriteCategoriesDocumentBegin" },
 432             { TraceCode.SyndicationWriteCategoriesDocumentEnd, "SyndicationWriteCategoriesDocumentEnd" },
 433             { TraceCode.AutomaticFormatSelectedOperationDefault, "AutomaticFormatSelectedOperationDefault" },
 434             { TraceCode.AutomaticFormatSelectedRequestBased, "AutomaticFormatSelectedRequestBased" },
 435             { TraceCode.RequestFormatSelectedFromContentTypeMapper, "RequestFormatSelectedFromContentTypeMapper" },
 436             { TraceCode.RequestFormatSelectedByEncoderDefaults, "RequestFormatSelectedByEncoderDefaults" },
 437             { TraceCode.AddingResponseToOutputCache, "AddingResponseToOutputCache" },
 438             { TraceCode.AddingAuthenticatedResponseToOutputCache, "AddingAuthenticatedResponseToOutputCache" },
 439             { TraceCode.JsonpCallbackNameSet, "JsonpCallbackNameSet" },
 440         };
 441
 442         public const string E2EActivityId = "E2EActivityId";
 443         public const string TraceApplicationReference = "TraceApplicationReference";
 444
 445         public static InputQueue<T> CreateInputQueue<T>() where T : class
 446         {
 447             if (asyncCallbackGenerator == null)
 448             {
 449                 asyncCallbackGenerator = new Func<Action<AsyncCallback, IAsyncResult>>(CallbackGenerator);
 450             }
 451
 452             return new InputQueue<T>(asyncCallbackGenerator)
 453             {
 454                 DisposeItemCallback = value =>
 455                     {
 456                         if (value is ICommunicationObject)
 457                         {
 458                             ((ICommunicationObject)value).Abort();
 459                         }
 460                     }
 461             };
 462         }
 463
 464         static Action<AsyncCallback, IAsyncResult> CallbackGenerator()
 465         {
 466             if (DiagnosticUtility.ShouldUseActivity)
 467             {
 468                 ServiceModelActivity callbackActivity = ServiceModelActivity.Current;
 469                 if (callbackActivity != null)
 470                 {
 471                     return delegate(AsyncCallback callback, IAsyncResult result)
 472                         {
 473                             using (ServiceModelActivity.BoundOperation(callbackActivity))
 474                             {
 475                                 callback(result);
 476                             }
 477                         };
 478                 }
 479             }
 480             return null;
 481         }
 482
 483         static internal void AddActivityHeader(Message message)
 484         {
 485             try
 486             {
 487                 ActivityIdHeader activityIdHeader = new ActivityIdHeader(TraceUtility.ExtractActivityId(message));
 488                 activityIdHeader.AddTo(message);
 489             }
 490 #pragma warning suppress 56500 // covered by FxCOP
 491             catch (Exception e)
 492             {
 493                 if (Fx.IsFatal(e))
 494                 {
 495                     throw;
 496                 }
 497                 TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToAddAnActivityIdHeader,
 498                     SR.GetString(SR.TraceCodeFailedToAddAnActivityIdHeader), e, message);
 499             }
 500         }
 501
 502         static internal void AddAmbientActivityToMessage(Message message)
 503         {
 504             try
 505             {
 506                 ActivityIdHeader activityIdHeader = new ActivityIdHeader(DiagnosticTraceBase.ActivityId);
 507                 activityIdHeader.AddTo(message);
 508             }
 509 #pragma warning suppress 56500 // covered by FxCOP
 510             catch (Exception e)
 511             {
 512                 if (Fx.IsFatal(e))
 513                 {
 514                     throw;
 515                 }
 516                 TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToAddAnActivityIdHeader,
 517                     SR.GetString(SR.TraceCodeFailedToAddAnActivityIdHeader), e, message);
 518             }
 519         }
 520
 521         static internal void CopyActivity(Message source, Message destination)
 522         {
 523             if (DiagnosticUtility.ShouldUseActivity)
 524             {
 525                 TraceUtility.SetActivity(destination, TraceUtility.ExtractActivity(source));
 526             }
 527         }
 528
 529         internal static long GetUtcBasedDurationForTrace(long startTicks)
 530         {
 531             if (startTicks > 0)
 532             {
 533                 TimeSpan elapsedTime = new TimeSpan(DateTime.UtcNow.Ticks - startTicks);
 534                 return (long)elapsedTime.TotalMilliseconds;
 535             }
 536             return 0;
 537         }
 538
 539         internal static ServiceModelActivity ExtractActivity(Message message)
 540         {
 541             ServiceModelActivity retval = null;
 542
 543             if ((DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivityGlobal) &&
 544                 (message != null) &&
 545                 (message.State != MessageState.Closed))
 546             {
 547                 object property;
 548
 549                 if (message.Properties.TryGetValue(TraceUtility.ActivityIdKey, out property))
 550                 {
 551                     retval = property as ServiceModelActivity;
 552                 }
 553             }
 554             return retval;
 555         }
 556
 557         internal static Guid ExtractActivityId(Message message)
 558         {
 559             if (TraceUtility.MessageFlowTracingOnly)
 560             {
 561                 return ActivityIdHeader.ExtractActivityId(message);
 562             }
 563
 564             ServiceModelActivity activity = ExtractActivity(message);
 565             return activity == null ? Guid.Empty : activity.Id;
 566         }
 567
 568         internal static Guid GetReceivedActivityId(OperationContext operationContext)
 569         {
 570             object activityIdFromProprties;
 571             if (!operationContext.IncomingMessageProperties.TryGetValue(E2EActivityId, out activityIdFromProprties))
 572             {
 573                 return TraceUtility.ExtractActivityId(operationContext.IncomingMessage);
 574             }
 575             else
 576             {
 577                 return (Guid)activityIdFromProprties;
 578             }
 579         }
 580
 581         internal static ServiceModelActivity ExtractAndRemoveActivity(Message message)
 582         {
 583             ServiceModelActivity retval = TraceUtility.ExtractActivity(message);
 584             if (retval != null)
 585             {
 586                 // If the property is just removed, the item is disposed and we don't want the thing
 587                 // to be disposed of.
 588                 message.Properties[TraceUtility.ActivityIdKey] = false;
 589             }
 590             return retval;
 591         }
 592
 593         internal static void ProcessIncomingMessage(Message message, EventTraceActivity eventTraceActivity)
 594         {
 595             ServiceModelActivity activity = ServiceModelActivity.Current;
 596             if (activity != null && DiagnosticUtility.ShouldUseActivity)
 597             {
 598                 ServiceModelActivity incomingActivity = TraceUtility.ExtractActivity(message);
 599                 if (null != incomingActivity && incomingActivity.Id != activity.Id)
 600                 {
 601                     using (ServiceModelActivity.BoundOperation(incomingActivity))
 602                     {
 603                         if (null != FxTrace.Trace)
 604                         {
 605                             FxTrace.Trace.TraceTransfer(activity.Id);
 606                         }
 607                     }
 608                 }
 609                 TraceUtility.SetActivity(message, activity);
 610             }
 611
 612             TraceUtility.MessageFlowAtMessageReceived(message, null, eventTraceActivity, true);
 613
 614             if (MessageLogger.LogMessagesAtServiceLevel)
 615             {
 616                 MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelReceiveReply | MessageLoggingSource.LastChance);
 617             }
 618         }
 619
 620         internal static void ProcessOutgoingMessage(Message message, EventTraceActivity eventTraceActivity)
 621         {
 622             ServiceModelActivity activity = ServiceModelActivity.Current;
 623             if (DiagnosticUtility.ShouldUseActivity)
 624             {
 625                 TraceUtility.SetActivity(message, activity);
 626             }
 627             if (TraceUtility.PropagateUserActivity || TraceUtility.ShouldPropagateActivity)
 628             {
 629                 TraceUtility.AddAmbientActivityToMessage(message);
 630             }
 631
 632             TraceUtility.MessageFlowAtMessageSent(message, eventTraceActivity);
 633
 634             if (MessageLogger.LogMessagesAtServiceLevel)
 635             {
 636                 MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelSendRequest | MessageLoggingSource.LastChance);
 637             }
 638         }
 639
 640         internal static void SetActivity(Message message, ServiceModelActivity activity)
 641         {
 642             if (DiagnosticUtility.ShouldUseActivity && message != null && message.State != MessageState.Closed)
 643             {
 644                 message.Properties[TraceUtility.ActivityIdKey] = activity;
 645             }
 646         }
 647
 648         internal static void TraceDroppedMessage(Message message, EndpointDispatcher dispatcher)
 649         {
 650             if (DiagnosticUtility.ShouldTraceInformation)
 651             {
 652                 EndpointAddress endpointAddress = null;
 653                 if (dispatcher != null)
 654                 {
 655                     endpointAddress = dispatcher.EndpointAddress;
 656                 }
 657                 TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.DroppedAMessage,
 658                     SR.GetString(SR.TraceCodeDroppedAMessage), new MessageDroppedTraceRecord(message, endpointAddress));
 659             }
 660         }
 661
 662         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription)
 663         {
 664             TraceEvent(severity, traceCode, traceDescription, null, traceDescription, (Exception)null);
 665         }
 666
 667         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData)
 668         {
 669             TraceEvent(severity, traceCode, traceDescription, extendedData, null, (Exception)null);
 670         }
 671
 672         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source)
 673         {
 674             TraceEvent(severity, traceCode, traceDescription, null, source, (Exception)null);
 675         }
 676
 677         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Exception exception)
 678         {
 679             TraceEvent(severity, traceCode, traceDescription, null, source, exception);
 680         }
 681
 682         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Message message)
 683         {
 684             if (message == null)
 685             {
 686                 TraceEvent(severity, traceCode, traceDescription, null, (Exception)null);
 687             }
 688             else
 689             {
 690                 TraceEvent(severity, traceCode, traceDescription, message, message);
 691             }
 692         }
 693
 694         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Message message)
 695         {
 696             Guid activityId = TraceUtility.ExtractActivityId(message);
 697             if (DiagnosticUtility.ShouldTrace(severity))
 698             {
 699                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), null, activityId, message);
 700             }
 701         }
 702
 703         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Exception exception, Message message)
 704         {
 705             Guid activityId = TraceUtility.ExtractActivityId(message);
 706             if (DiagnosticUtility.ShouldTrace(severity))
 707             {
 708                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), exception, activityId, null);
 709             }
 710         }
 711
 712         internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception)
 713         {
 714             DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source);
 715         }
 716
 717         // These methods require a TraceRecord to be allocated, so we want them to show up on profiles if the caller didn't avoid
 718         // allocating the TraceRecord by using ShouldTrace.
 719         [MethodImpl(MethodImplOptions.NoInlining)]
 720         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception)
 721         {
 722             if (DiagnosticUtility.ShouldTrace(severity))
 723             {
 724                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source);
 725             }
 726         }
 727
 728         [MethodImpl(MethodImplOptions.NoInlining)]
 729         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Message message)
 730         {
 731             Guid activityId = TraceUtility.ExtractActivityId(message);
 732             if (DiagnosticUtility.ShouldTrace(severity))
 733             {
 734                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 735                     traceDescription, extendedData, exception, activityId, source);
 736             }
 737         }
 738
 739         internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId)
 740         {
 741             DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 742                 traceDescription, extendedData, exception, activityId, source);
 743         }
 744
 745         [MethodImpl(MethodImplOptions.NoInlining)]
 746         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId)
 747         {
 748             if (DiagnosticUtility.ShouldTrace(severity))
 749             {
 750                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 751                     traceDescription, extendedData, exception, activityId, source);
 752             }
 753         }
 754
 755         static string GenerateMsdnTraceCode(int traceCode)
 756         {
 757             int group = (int)(traceCode & 0xFFFF0000);
 758             string terminatorUri = null;
 759             switch (group)
 760             {
 761                 case TraceCode.Administration:
 762                     terminatorUri = "System.ServiceModel.Administration";
 763                     break;
 764                 case TraceCode.Channels:
 765                     terminatorUri = "System.ServiceModel.Channels";
 766                     break;
 767                 case TraceCode.ComIntegration:
 768                     terminatorUri = "System.ServiceModel.ComIntegration";
 769                     break;
 770                 case TraceCode.Diagnostics:
 771                     terminatorUri = "System.ServiceModel.Diagnostics";
 772                     break;
 773                 case TraceCode.PortSharing:
 774                     terminatorUri = "System.ServiceModel.PortSharing";
 775                     break;
 776                 case TraceCode.Security:
 777                     terminatorUri = "System.ServiceModel.Security";
 778                     break;
 779                 case TraceCode.Serialization:
 780                     terminatorUri = "System.Runtime.Serialization";
 781                     break;
 782                 case TraceCode.ServiceModel:
 783                 case TraceCode.ServiceModelTransaction:
 784                     terminatorUri = "System.ServiceModel";
 785                     break;
 786                 default:
 787                     terminatorUri = string.Empty;
 788                     break;
 789             }
 790
 791             Fx.Assert(traceCodes.ContainsKey(traceCode),
 792                 string.Format(CultureInfo.InvariantCulture, "Unsupported trace code: Please add trace code 0x{0} to the SortedList TraceUtility.traceCodes in {1}",
 793                 traceCode.ToString("X", CultureInfo.InvariantCulture), typeof(TraceUtility)));
 794 #if !MONO
 795             return LegacyDiagnosticTrace.GenerateMsdnTraceCode(terminatorUri, traceCodes[traceCode]);
 796 #else
 797                 return "";
 798 #endif
 799         }
 800
 801         internal static Exception ThrowHelperError(Exception exception, Message message)
 802         {
 803             // If the message is closed, we won't get an activity
 804             Guid activityId = TraceUtility.ExtractActivityId(message);
 805             if (DiagnosticUtility.ShouldTraceError)
 806             {
 807                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 808                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null);
 809             }
 810             return exception;
 811         }
 812
 813         internal static Exception ThrowHelperError(Exception exception, Guid activityId, object source)
 814         {
 815             if (DiagnosticUtility.ShouldTraceError)
 816             {
 817                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 818                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, source);
 819             }
 820             return exception;
 821         }
 822
 823         internal static Exception ThrowHelperWarning(Exception exception, Message message)
 824         {
 825             if (DiagnosticUtility.ShouldTraceWarning)
 826             {
 827                 Guid activityId = TraceUtility.ExtractActivityId(message);
 828                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 829                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null);
 830             }
 831             return exception;
 832         }
 833
 834         internal static ArgumentException ThrowHelperArgument(string paramName, string message, Message msg)
 835         {
 836             return (ArgumentException)TraceUtility.ThrowHelperError(new ArgumentException(message, paramName), msg);
 837         }
 838
 839         internal static ArgumentNullException ThrowHelperArgumentNull(string paramName, Message message)
 840         {
 841             return (ArgumentNullException)TraceUtility.ThrowHelperError(new ArgumentNullException(paramName), message);
 842         }
 843
 844         internal static string CreateSourceString(object source)
 845         {
 846             return source.GetType().ToString() + "/" + source.GetHashCode().ToString(CultureInfo.CurrentCulture);
 847         }
 848
 849         internal static void TraceHttpConnectionInformation(string localEndpoint, string remoteEndpoint, object source)
 850         {
 851             if (DiagnosticUtility.ShouldTraceInformation)
 852             {
 853                 Dictionary<string, string> values = new Dictionary<string, string>(2)
 854                 {
 855                     { "LocalEndpoint", localEndpoint },
 856                     { "RemoteEndpoint", remoteEndpoint }
 857                 };
 858                 TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.ConnectToIPEndpoint,
 859                     SR.GetString(SR.TraceCodeConnectToIPEndpoint), new DictionaryTraceRecord(values), source, null);
 860             }
 861         }
 862
 863         internal static void TraceUserCodeException(Exception e, MethodInfo method)
 864         {
 865             if (DiagnosticUtility.ShouldTraceWarning)
 866             {
 867                 StringTraceRecord record = new StringTraceRecord("Comment",
 868                     SR.GetString(SR.SFxUserCodeThrewException, method.DeclaringType.FullName, method.Name));
 869                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
 870                     TraceCode.UnhandledExceptionInUserOperation, GenerateMsdnTraceCode(TraceCode.UnhandledExceptionInUserOperation),
 871                     SR.GetString(SR.TraceCodeUnhandledExceptionInUserOperation, method.DeclaringType.FullName, method.Name),
 872                     record,
 873                     e, null);
 874             }
 875         }
 876
 877         static TraceUtility()
 878         {
 879             //Maintain the order of calls
 880             TraceUtility.SetEtwProviderId();
 881             TraceUtility.SetEndToEndTracingFlags();
 882             if (DiagnosticUtility.DiagnosticTrace != null)
 883             {
 884                 DiagnosticTraceSource ts = (DiagnosticTraceSource)DiagnosticUtility.DiagnosticTrace.TraceSource;
 885                 TraceUtility.shouldPropagateActivity = (ts.PropagateActivity || TraceUtility.shouldPropagateActivityGlobal);
 886             }
 887         }
 888
 889         [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.",
 890             Safe = "Doesn't leak config section instance, just reads and stores bool values.")]
 891         [SecuritySafeCritical]
 892         static void SetEndToEndTracingFlags()
 893         {
 894             EndToEndTracingElement element = DiagnosticSection.UnsafeGetSection().EndToEndTracing;
 895             TraceUtility.shouldPropagateActivityGlobal = element.PropagateActivity;
 896             // if Sys.Diag trace is not enabled then the value is true if shouldPropagateActivityGlobal is true
 897             TraceUtility.shouldPropagateActivity = TraceUtility.shouldPropagateActivityGlobal || TraceUtility.shouldPropagateActivity;
 898
 899             //Activity tracing is enabled by either of the flags (Sys.Diag trace source or E2E config element)
 900             DiagnosticUtility.ShouldUseActivity = (DiagnosticUtility.ShouldUseActivity || element.ActivityTracing);
 901             TraceUtility.activityTracing = DiagnosticUtility.ShouldUseActivity;
 902
 903             TraceUtility.messageFlowTracing = element.MessageFlowTracing || TraceUtility.activityTracing;
 904             TraceUtility.messageFlowTracingOnly = element.MessageFlowTracing && !element.ActivityTracing;
 905
 906             //Set the flag if activity tracing is enabled through the E2E config element as well
 907             DiagnosticUtility.TracingEnabled = (DiagnosticUtility.TracingEnabled || TraceUtility.activityTracing);
 908         }
 909
 910         static public long RetrieveMessageNumber()
 911         {
 912             return Interlocked.Increment(ref TraceUtility.messageNumber);
 913         }
 914
 915         static public bool PropagateUserActivity
 916         {
 917             get
 918             {
 919                 return TraceUtility.ShouldPropagateActivity &&
 920                     TraceUtility.PropagateUserActivityCore;
 921             }
 922         }
 923
 924         // Most of the time, shouldPropagateActivity will be false.
 925         // This property will rarely be executed as a result.
 926         static bool PropagateUserActivityCore
 927         {
 928             [MethodImpl(MethodImplOptions.NoInlining)]
 929             get
 930             {
 931                 return !(DiagnosticUtility.TracingEnabled) &&
 932                     DiagnosticTraceBase.ActivityId != Guid.Empty;
 933             }
 934         }
 935
 936         static internal string GetCallerInfo(OperationContext context)
 937         {
 938             if (context != null && context.IncomingMessageProperties != null)
 939             {
 940                 object endpointMessageProperty;
 941                 if (context.IncomingMessageProperties.TryGetValue(RemoteEndpointMessageProperty.Name, out endpointMessageProperty))
 942                 {
 943                     RemoteEndpointMessageProperty endpoint = endpointMessageProperty as RemoteEndpointMessageProperty;
 944                     if (endpoint != null)
 945                     {
 946                         return string.Format(CultureInfo.InvariantCulture, "{0}:{1}", endpoint.Address, endpoint.Port);
 947                     }
 948                 }
 949             }
 950             return "null";
 951         }
 952
 953         [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.",
 954             Safe = "Doesn't leak config section instance, just reads and stores string values for Guid")]
 955         [SecuritySafeCritical]
 956         static internal void SetEtwProviderId()
 957         {
 958             // Get section should not trace as the ETW provider id is not set yet
 959             DiagnosticSection diagnostics = DiagnosticSection.UnsafeGetSectionNoTrace();
 960             Guid etwProviderId = Guid.Empty;
 961             //set the Id in PT if specified in the config file. If not, ETW tracing is off.
 962             if (PartialTrustHelpers.HasEtwPermissions() || diagnostics.IsEtwProviderIdFromConfigFile())
 963             {
 964                 etwProviderId = Fx.CreateGuid(diagnostics.EtwProviderId);
 965             }
 966             System.Runtime.Diagnostics.EtwDiagnosticTrace.DefaultEtwProviderId = etwProviderId;
 967         }
 968
 969         static internal void SetActivityId(MessageProperties properties)
 970         {
 971             Guid activityId;
 972             if ((null != properties) && properties.TryGetValue(TraceUtility.E2EActivityId, out activityId))
 973             {
 974                 DiagnosticTraceBase.ActivityId = activityId;
 975             }
 976         }
 977
 978         static internal bool ShouldPropagateActivity
 979         {
 980             get { return TraceUtility.shouldPropagateActivity; }
 981         }
 982
 983         static internal bool ShouldPropagateActivityGlobal
 984         {
 985             get { return TraceUtility.shouldPropagateActivityGlobal; }
 986         }
 987
 988         static internal bool ActivityTracing
 989         {
 990             get { return TraceUtility.activityTracing; }
 991         }
 992
 993         static internal bool MessageFlowTracing
 994         {
 995             get { return TraceUtility.messageFlowTracing; }
 996         }
 997
 998         static internal bool MessageFlowTracingOnly
 999         {
1000             get { return TraceUtility.messageFlowTracingOnly; }
1001         }
1002
1003         static internal void MessageFlowAtMessageSent(Message message, EventTraceActivity eventTraceActivity)
1004         {
1005             if (TraceUtility.MessageFlowTracing)
1006             {
1007                 Guid activityId;
1008                 Guid correlationId;
1009                 bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId);
1010
1011                 if (TraceUtility.MessageFlowTracingOnly)
1012                 {
1013                     if (activityIdFound && activityId != DiagnosticTraceBase.ActivityId)
1014                     {
1015                         DiagnosticTraceBase.ActivityId = activityId;
1016                     }
1017                 }
1018
1019                 if (TD.MessageSentToTransportIsEnabled())
1020                 {
1021                     TD.MessageSentToTransport(eventTraceActivity, correlationId);
1022                 }
1023             }
1024         }
1025
1026         static internal void MessageFlowAtMessageReceived(Message message, OperationContext context, EventTraceActivity eventTraceActivity, bool createNewActivityId)
1027         {
1028             if (TraceUtility.MessageFlowTracing)
1029             {
1030                 Guid activityId;
1031                 Guid correlationId;
1032                 bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId);
1033                 if (TraceUtility.MessageFlowTracingOnly)
1034                 {
1035                     if (createNewActivityId)
1036                     {
1037                         if (!activityIdFound)
1038                         {
1039                             activityId = Guid.NewGuid();
1040                             activityIdFound = true;
1041                         }
1042                         //message flow tracing only - start fresh
1043                         DiagnosticTraceBase.ActivityId = Guid.Empty;
1044                     }
1045
1046                     if (activityIdFound)
1047                     {
1048                         FxTrace.Trace.SetAndTraceTransfer(activityId, !createNewActivityId);
1049                         message.Properties[TraceUtility.E2EActivityId] = Trace.CorrelationManager.ActivityId;
1050                     }
1051                 }
1052                 if (TD.MessageReceivedFromTransportIsEnabled())
1053                 {
1054                     if (context == null)
1055                     {
1056                         context = OperationContext.Current;
1057                     }
1058
1059                     TD.MessageReceivedFromTransport(eventTraceActivity, correlationId, TraceUtility.GetAnnotation(context));
1060                 }
1061             }
1062         }
1063
1064         internal static string GetAnnotation(OperationContext context)
1065         {
1066             object hostReference;
1067             if (context != null && null != context.IncomingMessage && (MessageState.Closed != context.IncomingMessage.State))
1068             {
1069                 if (!context.IncomingMessageProperties.TryGetValue(TraceApplicationReference, out hostReference))
1070                 {
1071                     hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(context.Host);
1072                     context.IncomingMessageProperties.Add(TraceApplicationReference, hostReference);
1073                 }
1074             }
1075             else
1076             {
1077                 hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(null);
1078             }
1079             return (string)hostReference;
1080         }
1081
1082         internal static void TransferFromTransport(Message message)
1083         {
1084             if (message != null && DiagnosticUtility.ShouldUseActivity)
1085             {
1086                 Guid guid = Guid.Empty;
1087
1088                 // Only look if we are allowing user propagation
1089                 if (TraceUtility.ShouldPropagateActivity)
1090                 {
1091                     guid = ActivityIdHeader.ExtractActivityId(message);
1092                 }
1093
1094                 if (guid == Guid.Empty)
1095                 {
1096                     guid = Guid.NewGuid();
1097                 }
1098
1099                 ServiceModelActivity activity = null;
1100                 bool emitStart = true;
1101                 if (ServiceModelActivity.Current != null)
1102                 {
1103                     if ((ServiceModelActivity.Current.Id == guid) ||
1104                         (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction))
1105                     {
1106                         activity = ServiceModelActivity.Current;
1107                         emitStart = false;
1108                     }
1109                     else if (ServiceModelActivity.Current.PreviousActivity != null &&
1110                         ServiceModelActivity.Current.PreviousActivity.Id == guid)
1111                     {
1112                         activity = ServiceModelActivity.Current.PreviousActivity;
1113                         emitStart = false;
1114                     }
1115                 }
1116
1117                 if (activity == null)
1118                 {
1119                     activity = ServiceModelActivity.CreateActivity(guid);
1120                 }
1121                 if (DiagnosticUtility.ShouldUseActivity)
1122                 {
1123                     if (emitStart)
1124                     {
1125                         if (null != FxTrace.Trace)
1126                         {
1127                             FxTrace.Trace.TraceTransfer(guid);
1128                         }
1129                         ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityProcessAction, message.Headers.Action), ActivityType.ProcessAction);
1130                     }
1131                 }
1132                 message.Properties[TraceUtility.ActivityIdKey] = activity;
1133             }
1134         }
1135
1136         static internal void UpdateAsyncOperationContextWithActivity(object activity)
1137         {
1138             if (OperationContext.Current != null && activity != null)
1139             {
1140                 OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationActivityKey] = activity;
1141             }
1142         }
1143
1144         static internal object ExtractAsyncOperationContextActivity()
1145         {
1146             object data = null;
1147             if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue(TraceUtility.AsyncOperationActivityKey, out data))
1148             {
1149                 OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationActivityKey);
1150             }
1151             return data;
1152         }
1153
1154         static internal void UpdateAsyncOperationContextWithStartTime(EventTraceActivity eventTraceActivity, long startTime)
1155         {
1156             if (OperationContext.Current != null)
1157             {
1158                 OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationStartTimeKey] = new EventTraceActivityTimeProperty(eventTraceActivity, startTime);
1159             }
1160         }
1161
1162         static internal void ExtractAsyncOperationStartTime(out EventTraceActivity eventTraceActivity, out long startTime)
1163         {
1164             EventTraceActivityTimeProperty data = null;
1165             eventTraceActivity = null;
1166             startTime = 0;
1167             if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue<EventTraceActivityTimeProperty>(TraceUtility.AsyncOperationStartTimeKey, out data))
1168             {
1169                 OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationStartTimeKey);
1170                 eventTraceActivity = data.EventTraceActivity;
1171                 startTime = data.StartTime;
1172             }
1173         }
1174
1175         internal class TracingAsyncCallbackState
1176         {
1177             object innerState;
1178             Guid activityId;
1179
1180             internal TracingAsyncCallbackState(object innerState)
1181             {
1182                 this.innerState = innerState;
1183                 this.activityId = DiagnosticTraceBase.ActivityId;
1184             }
1185
1186             internal object InnerState
1187             {
1188                 get { return this.innerState; }
1189             }
1190
1191             internal Guid ActivityId
1192             {
1193                 get { return this.activityId; }
1194             }
1195         }
1196
1197         internal static AsyncCallback WrapExecuteUserCodeAsyncCallback(AsyncCallback callback)
1198         {
1199             return (DiagnosticUtility.ShouldUseActivity && callback != null) ?
1200                 (new ExecuteUserCodeAsync(callback)).Callback
1201                 : callback;
1202         }
1203
1204         sealed class ExecuteUserCodeAsync
1205         {
1206             AsyncCallback callback;
1207
1208             public ExecuteUserCodeAsync(AsyncCallback callback)
1209             {
1210                 this.callback = callback;
1211             }
1212
1213             public AsyncCallback Callback
1214             {
1215                 get
1216                 {
1217                     return Fx.ThunkCallback(new AsyncCallback(this.ExecuteUserCode));
1218                 }
1219             }
1220
1221             void ExecuteUserCode(IAsyncResult result)
1222             {
1223                 using (ServiceModelActivity activity = ServiceModelActivity.CreateBoundedActivity())
1224                 {
1225                     ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityCallback), ActivityType.ExecuteUserCode);
1226                     this.callback(result);
1227                 }
1228             }
1229         }
1230
1231
1232         class EventTraceActivityTimeProperty
1233         {
1234             long startTime;
1235             EventTraceActivity eventTraceActivity;
1236
1237             public EventTraceActivityTimeProperty(EventTraceActivity eventTraceActivity, long startTime)
1238             {
1239                 this.eventTraceActivity = eventTraceActivity;
1240                 this.startTime = startTime;
1241             }
1242
1243             internal long StartTime
1244             {
1245                 get { return this.startTime; }
1246             }
1247             internal EventTraceActivity EventTraceActivity
1248             {
1249                 get { return this.eventTraceActivity; }
1250             }
1251         }
1252
1253
1254         internal static string GetRemoteEndpointAddressPort(Net.IPEndPoint iPEndPoint)
1255         {
1256             //We really don't want any exceptions out of TraceUtility.
1257             if (iPEndPoint != null)
1258             {
1259                 try
1260                 {
1261                     return iPEndPoint.Address.ToString() + ":" + iPEndPoint.Port;
1262                 }
1263                 catch (Exception exception)
1264                 {
1265                     if (Fx.IsFatal(exception))
1266                     {
1267                         throw;
1268                     }
1269                     //ignore and continue with all non-fatal exceptions.
1270                 }
1271             }
1272
1273             return string.Empty;
1274         }
1275
1276         internal static string GetRemoteEndpointAddressPort(RemoteEndpointMessageProperty remoteEndpointMessageProperty)
1277         {
1278             try
1279             {
1280                 if (remoteEndpointMessageProperty != null)
1281                 {
1282                     return remoteEndpointMessageProperty.Address + ":" + remoteEndpointMessageProperty.Port;
1283                 }
1284             }
1285             catch (Exception exception)
1286             {
1287                 if (Fx.IsFatal(exception))
1288                 {
1289                     throw;
1290                 }
1291                 //ignore and continue with all non-fatal exceptions.
1292             }
1293
1294             return string.Empty;
1295         }
1296     }
1297 }