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
 558         internal static ServiceModelActivity ExtractActivity(RequestContext request)
 559         {
 560             try
 561             {
 562                 return TraceUtility.ExtractActivity(request.RequestMessage);
 563             }
 564             catch (Exception e)
 565             {
 566                 if (Fx.IsFatal(e))
 567                 {
 568                     throw;
 569                 }
 570             }
 571
 572             return null;
 573         }
 574
 575         internal static Guid ExtractActivityId(Message message)
 576         {
 577             if (TraceUtility.MessageFlowTracingOnly)
 578             {
 579                 return ActivityIdHeader.ExtractActivityId(message);
 580             }
 581
 582             ServiceModelActivity activity = ExtractActivity(message);
 583             return activity == null ? Guid.Empty : activity.Id;
 584         }
 585
 586         internal static Guid GetReceivedActivityId(OperationContext operationContext)
 587         {
 588             object activityIdFromProprties;
 589             if (!operationContext.IncomingMessageProperties.TryGetValue(E2EActivityId, out activityIdFromProprties))
 590             {
 591                 return TraceUtility.ExtractActivityId(operationContext.IncomingMessage);
 592             }
 593             else
 594             {
 595                 return (Guid)activityIdFromProprties;
 596             }
 597         }
 598
 599         internal static ServiceModelActivity ExtractAndRemoveActivity(Message message)
 600         {
 601             ServiceModelActivity retval = TraceUtility.ExtractActivity(message);
 602             if (retval != null)
 603             {
 604                 // If the property is just removed, the item is disposed and we don't want the thing
 605                 // to be disposed of.
 606                 message.Properties[TraceUtility.ActivityIdKey] = false;
 607             }
 608             return retval;
 609         }
 610
 611         internal static void ProcessIncomingMessage(Message message, EventTraceActivity eventTraceActivity)
 612         {
 613             ServiceModelActivity activity = ServiceModelActivity.Current;
 614             if (activity != null && DiagnosticUtility.ShouldUseActivity)
 615             {
 616                 ServiceModelActivity incomingActivity = TraceUtility.ExtractActivity(message);
 617                 if (null != incomingActivity && incomingActivity.Id != activity.Id)
 618                 {
 619                     using (ServiceModelActivity.BoundOperation(incomingActivity))
 620                     {
 621                         if (null != FxTrace.Trace)
 622                         {
 623                             FxTrace.Trace.TraceTransfer(activity.Id);
 624                         }
 625                     }
 626                 }
 627                 TraceUtility.SetActivity(message, activity);
 628             }
 629
 630             TraceUtility.MessageFlowAtMessageReceived(message, null, eventTraceActivity, true);
 631
 632             if (MessageLogger.LogMessagesAtServiceLevel)
 633             {
 634                 MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelReceiveReply | MessageLoggingSource.LastChance);
 635             }
 636         }
 637
 638         internal static void ProcessOutgoingMessage(Message message, EventTraceActivity eventTraceActivity)
 639         {
 640             ServiceModelActivity activity = ServiceModelActivity.Current;
 641             if (DiagnosticUtility.ShouldUseActivity)
 642             {
 643                 TraceUtility.SetActivity(message, activity);
 644             }
 645             if (TraceUtility.PropagateUserActivity || TraceUtility.ShouldPropagateActivity)
 646             {
 647                 TraceUtility.AddAmbientActivityToMessage(message);
 648             }
 649
 650             TraceUtility.MessageFlowAtMessageSent(message, eventTraceActivity);
 651
 652             if (MessageLogger.LogMessagesAtServiceLevel)
 653             {
 654                 MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelSendRequest | MessageLoggingSource.LastChance);
 655             }
 656         }
 657
 658         internal static void SetActivity(Message message, ServiceModelActivity activity)
 659         {
 660             if (DiagnosticUtility.ShouldUseActivity && message != null && message.State != MessageState.Closed)
 661             {
 662                 message.Properties[TraceUtility.ActivityIdKey] = activity;
 663             }
 664         }
 665
 666         internal static void TraceDroppedMessage(Message message, EndpointDispatcher dispatcher)
 667         {
 668             if (DiagnosticUtility.ShouldTraceInformation)
 669             {
 670                 EndpointAddress endpointAddress = null;
 671                 if (dispatcher != null)
 672                 {
 673                     endpointAddress = dispatcher.EndpointAddress;
 674                 }
 675                 TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.DroppedAMessage,
 676                     SR.GetString(SR.TraceCodeDroppedAMessage), new MessageDroppedTraceRecord(message, endpointAddress));
 677             }
 678         }
 679
 680         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription)
 681         {
 682             TraceEvent(severity, traceCode, traceDescription, null, traceDescription, (Exception)null);
 683         }
 684
 685         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData)
 686         {
 687             TraceEvent(severity, traceCode, traceDescription, extendedData, null, (Exception)null);
 688         }
 689
 690         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source)
 691         {
 692             TraceEvent(severity, traceCode, traceDescription, null, source, (Exception)null);
 693         }
 694
 695         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Exception exception)
 696         {
 697             TraceEvent(severity, traceCode, traceDescription, null, source, exception);
 698         }
 699
 700         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Message message)
 701         {
 702             if (message == null)
 703             {
 704                 TraceEvent(severity, traceCode, traceDescription, null, (Exception)null);
 705             }
 706             else
 707             {
 708                 TraceEvent(severity, traceCode, traceDescription, message, message);
 709             }
 710         }
 711
 712         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Message message)
 713         {
 714             Guid activityId = TraceUtility.ExtractActivityId(message);
 715             if (DiagnosticUtility.ShouldTrace(severity))
 716             {
 717                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), null, activityId, message);
 718             }
 719         }
 720
 721         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Exception exception, Message message)
 722         {
 723             Guid activityId = TraceUtility.ExtractActivityId(message);
 724             if (DiagnosticUtility.ShouldTrace(severity))
 725             {
 726                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), exception, activityId, null);
 727             }
 728         }
 729
 730         internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception)
 731         {
 732             DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source);
 733         }
 734
 735         // These methods require a TraceRecord to be allocated, so we want them to show up on profiles if the caller didn't avoid
 736         // allocating the TraceRecord by using ShouldTrace.
 737         [MethodImpl(MethodImplOptions.NoInlining)]
 738         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception)
 739         {
 740             if (DiagnosticUtility.ShouldTrace(severity))
 741             {
 742                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source);
 743             }
 744         }
 745
 746         [MethodImpl(MethodImplOptions.NoInlining)]
 747         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Message message)
 748         {
 749             Guid activityId = TraceUtility.ExtractActivityId(message);
 750             if (DiagnosticUtility.ShouldTrace(severity))
 751             {
 752                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 753                     traceDescription, extendedData, exception, activityId, source);
 754             }
 755         }
 756
 757         internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId)
 758         {
 759             DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 760                 traceDescription, extendedData, exception, activityId, source);
 761         }
 762
 763         [MethodImpl(MethodImplOptions.NoInlining)]
 764         internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId)
 765         {
 766             if (DiagnosticUtility.ShouldTrace(severity))
 767             {
 768                 DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode),
 769                     traceDescription, extendedData, exception, activityId, source);
 770             }
 771         }
 772
 773         static string GenerateMsdnTraceCode(int traceCode)
 774         {
 775             int group = (int)(traceCode & 0xFFFF0000);
 776             string terminatorUri = null;
 777             switch (group)
 778             {
 779                 case TraceCode.Administration:
 780                     terminatorUri = "System.ServiceModel.Administration";
 781                     break;
 782                 case TraceCode.Channels:
 783                     terminatorUri = "System.ServiceModel.Channels";
 784                     break;
 785                 case TraceCode.ComIntegration:
 786                     terminatorUri = "System.ServiceModel.ComIntegration";
 787                     break;
 788                 case TraceCode.Diagnostics:
 789                     terminatorUri = "System.ServiceModel.Diagnostics";
 790                     break;
 791                 case TraceCode.PortSharing:
 792                     terminatorUri = "System.ServiceModel.PortSharing";
 793                     break;
 794                 case TraceCode.Security:
 795                     terminatorUri = "System.ServiceModel.Security";
 796                     break;
 797                 case TraceCode.Serialization:
 798                     terminatorUri = "System.Runtime.Serialization";
 799                     break;
 800                 case TraceCode.ServiceModel:
 801                 case TraceCode.ServiceModelTransaction:
 802                     terminatorUri = "System.ServiceModel";
 803                     break;
 804                 default:
 805                     terminatorUri = string.Empty;
 806                     break;
 807             }
 808
 809             Fx.Assert(traceCodes.ContainsKey(traceCode),
 810                 string.Format(CultureInfo.InvariantCulture, "Unsupported trace code: Please add trace code 0x{0} to the SortedList TraceUtility.traceCodes in {1}",
 811                 traceCode.ToString("X", CultureInfo.InvariantCulture), typeof(TraceUtility)));
 812 #if !MONO
 813             return LegacyDiagnosticTrace.GenerateMsdnTraceCode(terminatorUri, traceCodes[traceCode]);
 814 #else
 815                 return "";
 816 #endif
 817         }
 818
 819         internal static Exception ThrowHelperError(Exception exception, Message message)
 820         {
 821             // If the message is closed, we won't get an activity
 822             Guid activityId = TraceUtility.ExtractActivityId(message);
 823             if (DiagnosticUtility.ShouldTraceError)
 824             {
 825                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 826                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null);
 827             }
 828             return exception;
 829         }
 830
 831         internal static Exception ThrowHelperError(Exception exception, Guid activityId, object source)
 832         {
 833             if (DiagnosticUtility.ShouldTraceError)
 834             {
 835                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 836                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, source);
 837             }
 838             return exception;
 839         }
 840
 841         internal static Exception ThrowHelperWarning(Exception exception, Message message)
 842         {
 843             if (DiagnosticUtility.ShouldTraceWarning)
 844             {
 845                 Guid activityId = TraceUtility.ExtractActivityId(message);
 846                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException),
 847                     TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null);
 848             }
 849             return exception;
 850         }
 851
 852         internal static ArgumentException ThrowHelperArgument(string paramName, string message, Message msg)
 853         {
 854             return (ArgumentException)TraceUtility.ThrowHelperError(new ArgumentException(message, paramName), msg);
 855         }
 856
 857         internal static ArgumentNullException ThrowHelperArgumentNull(string paramName, Message message)
 858         {
 859             return (ArgumentNullException)TraceUtility.ThrowHelperError(new ArgumentNullException(paramName), message);
 860         }
 861
 862         internal static string CreateSourceString(object source)
 863         {
 864             return source.GetType().ToString() + "/" + source.GetHashCode().ToString(CultureInfo.CurrentCulture);
 865         }
 866
 867         internal static void TraceHttpConnectionInformation(string localEndpoint, string remoteEndpoint, object source)
 868         {
 869             if (DiagnosticUtility.ShouldTraceInformation)
 870             {
 871                 Dictionary<string, string> values = new Dictionary<string, string>(2)
 872                 {
 873                     { "LocalEndpoint", localEndpoint },
 874                     { "RemoteEndpoint", remoteEndpoint }
 875                 };
 876                 TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.ConnectToIPEndpoint,
 877                     SR.GetString(SR.TraceCodeConnectToIPEndpoint), new DictionaryTraceRecord(values), source, null);
 878             }
 879         }
 880
 881         internal static void TraceUserCodeException(Exception e, MethodInfo method)
 882         {
 883             if (DiagnosticUtility.ShouldTraceWarning)
 884             {
 885                 StringTraceRecord record = new StringTraceRecord("Comment",
 886                     SR.GetString(SR.SFxUserCodeThrewException, method.DeclaringType.FullName, method.Name));
 887                 DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
 888                     TraceCode.UnhandledExceptionInUserOperation, GenerateMsdnTraceCode(TraceCode.UnhandledExceptionInUserOperation),
 889                     SR.GetString(SR.TraceCodeUnhandledExceptionInUserOperation, method.DeclaringType.FullName, method.Name),
 890                     record,
 891                     e, null);
 892             }
 893         }
 894
 895         static TraceUtility()
 896         {
 897             //Maintain the order of calls
 898             TraceUtility.SetEtwProviderId();
 899             TraceUtility.SetEndToEndTracingFlags();
 900             if (DiagnosticUtility.DiagnosticTrace != null)
 901             {
 902                 DiagnosticTraceSource ts = (DiagnosticTraceSource)DiagnosticUtility.DiagnosticTrace.TraceSource;
 903                 TraceUtility.shouldPropagateActivity = (ts.PropagateActivity || TraceUtility.shouldPropagateActivityGlobal);
 904             }
 905         }
 906
 907         [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.",
 908             Safe = "Doesn't leak config section instance, just reads and stores bool values.")]
 909         [SecuritySafeCritical]
 910         static void SetEndToEndTracingFlags()
 911         {
 912             EndToEndTracingElement element = DiagnosticSection.UnsafeGetSection().EndToEndTracing;
 913             TraceUtility.shouldPropagateActivityGlobal = element.PropagateActivity;
 914             // if Sys.Diag trace is not enabled then the value is true if shouldPropagateActivityGlobal is true
 915             TraceUtility.shouldPropagateActivity = TraceUtility.shouldPropagateActivityGlobal || TraceUtility.shouldPropagateActivity;
 916
 917             //Activity tracing is enabled by either of the flags (Sys.Diag trace source or E2E config element)
 918             DiagnosticUtility.ShouldUseActivity = (DiagnosticUtility.ShouldUseActivity || element.ActivityTracing);
 919             TraceUtility.activityTracing = DiagnosticUtility.ShouldUseActivity;
 920
 921             TraceUtility.messageFlowTracing = element.MessageFlowTracing || TraceUtility.activityTracing;
 922             TraceUtility.messageFlowTracingOnly = element.MessageFlowTracing && !element.ActivityTracing;
 923
 924             //Set the flag if activity tracing is enabled through the E2E config element as well
 925             DiagnosticUtility.TracingEnabled = (DiagnosticUtility.TracingEnabled || TraceUtility.activityTracing);
 926         }
 927
 928         static public long RetrieveMessageNumber()
 929         {
 930             return Interlocked.Increment(ref TraceUtility.messageNumber);
 931         }
 932
 933         static public bool PropagateUserActivity
 934         {
 935             get
 936             {
 937                 return TraceUtility.ShouldPropagateActivity &&
 938                     TraceUtility.PropagateUserActivityCore;
 939             }
 940         }
 941
 942         // Most of the time, shouldPropagateActivity will be false.
 943         // This property will rarely be executed as a result.
 944         static bool PropagateUserActivityCore
 945         {
 946             [MethodImpl(MethodImplOptions.NoInlining)]
 947             get
 948             {
 949                 return !(DiagnosticUtility.TracingEnabled) &&
 950                     DiagnosticTraceBase.ActivityId != Guid.Empty;
 951             }
 952         }
 953
 954         static internal string GetCallerInfo(OperationContext context)
 955         {
 956             if (context != null && context.IncomingMessageProperties != null)
 957             {
 958                 object endpointMessageProperty;
 959                 if (context.IncomingMessageProperties.TryGetValue(RemoteEndpointMessageProperty.Name, out endpointMessageProperty))
 960                 {
 961                     RemoteEndpointMessageProperty endpoint = endpointMessageProperty as RemoteEndpointMessageProperty;
 962                     if (endpoint != null)
 963                     {
 964                         return string.Format(CultureInfo.InvariantCulture, "{0}:{1}", endpoint.Address, endpoint.Port);
 965                     }
 966                 }
 967             }
 968             return "null";
 969         }
 970
 971         [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.",
 972             Safe = "Doesn't leak config section instance, just reads and stores string values for Guid")]
 973         [SecuritySafeCritical]
 974         static internal void SetEtwProviderId()
 975         {
 976             // Get section should not trace as the ETW provider id is not set yet
 977             DiagnosticSection diagnostics = DiagnosticSection.UnsafeGetSectionNoTrace();
 978             Guid etwProviderId = Guid.Empty;
 979             //set the Id in PT if specified in the config file. If not, ETW tracing is off.
 980             if (PartialTrustHelpers.HasEtwPermissions() || diagnostics.IsEtwProviderIdFromConfigFile())
 981             {
 982                 etwProviderId = Fx.CreateGuid(diagnostics.EtwProviderId);
 983             }
 984             System.Runtime.Diagnostics.EtwDiagnosticTrace.DefaultEtwProviderId = etwProviderId;
 985         }
 986
 987         static internal void SetActivityId(MessageProperties properties)
 988         {
 989             Guid activityId;
 990             if ((null != properties) && properties.TryGetValue(TraceUtility.E2EActivityId, out activityId))
 991             {
 992                 DiagnosticTraceBase.ActivityId = activityId;
 993             }
 994         }
 995
 996         static internal bool ShouldPropagateActivity
 997         {
 998             get { return TraceUtility.shouldPropagateActivity; }
 999         }
1000
1001         static internal bool ShouldPropagateActivityGlobal
1002         {
1003             get { return TraceUtility.shouldPropagateActivityGlobal; }
1004         }
1005
1006         static internal bool ActivityTracing
1007         {
1008             get { return TraceUtility.activityTracing; }
1009         }
1010
1011         static internal bool MessageFlowTracing
1012         {
1013             get { return TraceUtility.messageFlowTracing; }
1014         }
1015
1016         static internal bool MessageFlowTracingOnly
1017         {
1018             get { return TraceUtility.messageFlowTracingOnly; }
1019         }
1020
1021         static internal void MessageFlowAtMessageSent(Message message, EventTraceActivity eventTraceActivity)
1022         {
1023             if (TraceUtility.MessageFlowTracing)
1024             {
1025                 Guid activityId;
1026                 Guid correlationId;
1027                 bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId);
1028
1029                 if (TraceUtility.MessageFlowTracingOnly)
1030                 {
1031                     if (activityIdFound && activityId != DiagnosticTraceBase.ActivityId)
1032                     {
1033                         DiagnosticTraceBase.ActivityId = activityId;
1034                     }
1035                 }
1036
1037                 if (TD.MessageSentToTransportIsEnabled())
1038                 {
1039                     TD.MessageSentToTransport(eventTraceActivity, correlationId);
1040                 }
1041             }
1042         }
1043
1044         static internal void MessageFlowAtMessageReceived(Message message, OperationContext context, EventTraceActivity eventTraceActivity, bool createNewActivityId)
1045         {
1046             if (TraceUtility.MessageFlowTracing)
1047             {
1048                 Guid activityId;
1049                 Guid correlationId;
1050                 bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId);
1051                 if (TraceUtility.MessageFlowTracingOnly)
1052                 {
1053                     if (createNewActivityId)
1054                     {
1055                         if (!activityIdFound)
1056                         {
1057                             activityId = Guid.NewGuid();
1058                             activityIdFound = true;
1059                         }
1060                         //message flow tracing only - start fresh
1061                         DiagnosticTraceBase.ActivityId = Guid.Empty;
1062                     }
1063
1064                     if (activityIdFound)
1065                     {
1066                         FxTrace.Trace.SetAndTraceTransfer(activityId, !createNewActivityId);
1067                         message.Properties[TraceUtility.E2EActivityId] = Trace.CorrelationManager.ActivityId;
1068                     }
1069                 }
1070                 if (TD.MessageReceivedFromTransportIsEnabled())
1071                 {
1072                     if (context == null)
1073                     {
1074                         context = OperationContext.Current;
1075                     }
1076
1077                     TD.MessageReceivedFromTransport(eventTraceActivity, correlationId, TraceUtility.GetAnnotation(context));
1078                 }
1079             }
1080         }
1081
1082         internal static string GetAnnotation(OperationContext context)
1083         {
1084             object hostReference;
1085             if (context != null && null != context.IncomingMessage && (MessageState.Closed != context.IncomingMessage.State))
1086             {
1087                 if (!context.IncomingMessageProperties.TryGetValue(TraceApplicationReference, out hostReference))
1088                 {
1089                     hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(context.Host);
1090                     context.IncomingMessageProperties.Add(TraceApplicationReference, hostReference);
1091                 }
1092             }
1093             else
1094             {
1095                 hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(null);
1096             }
1097             return (string)hostReference;
1098         }
1099
1100         internal static void TransferFromTransport(Message message)
1101         {
1102             if (message != null && DiagnosticUtility.ShouldUseActivity)
1103             {
1104                 Guid guid = Guid.Empty;
1105
1106                 // Only look if we are allowing user propagation
1107                 if (TraceUtility.ShouldPropagateActivity)
1108                 {
1109                     guid = ActivityIdHeader.ExtractActivityId(message);
1110                 }
1111
1112                 if (guid == Guid.Empty)
1113                 {
1114                     guid = Guid.NewGuid();
1115                 }
1116
1117                 ServiceModelActivity activity = null;
1118                 bool emitStart = true;
1119                 if (ServiceModelActivity.Current != null)
1120                 {
1121                     if ((ServiceModelActivity.Current.Id == guid) ||
1122                         (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction))
1123                     {
1124                         activity = ServiceModelActivity.Current;
1125                         emitStart = false;
1126                     }
1127                     else if (ServiceModelActivity.Current.PreviousActivity != null &&
1128                         ServiceModelActivity.Current.PreviousActivity.Id == guid)
1129                     {
1130                         activity = ServiceModelActivity.Current.PreviousActivity;
1131                         emitStart = false;
1132                     }
1133                 }
1134
1135                 if (activity == null)
1136                 {
1137                     activity = ServiceModelActivity.CreateActivity(guid);
1138                 }
1139                 if (DiagnosticUtility.ShouldUseActivity)
1140                 {
1141                     if (emitStart)
1142                     {
1143                         if (null != FxTrace.Trace)
1144                         {
1145                             FxTrace.Trace.TraceTransfer(guid);
1146                         }
1147                         ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityProcessAction, message.Headers.Action), ActivityType.ProcessAction);
1148                     }
1149                 }
1150                 message.Properties[TraceUtility.ActivityIdKey] = activity;
1151             }
1152         }
1153
1154         static internal void UpdateAsyncOperationContextWithActivity(object activity)
1155         {
1156             if (OperationContext.Current != null && activity != null)
1157             {
1158                 OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationActivityKey] = activity;
1159             }
1160         }
1161
1162         static internal object ExtractAsyncOperationContextActivity()
1163         {
1164             object data = null;
1165             if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue(TraceUtility.AsyncOperationActivityKey, out data))
1166             {
1167                 OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationActivityKey);
1168             }
1169             return data;
1170         }
1171
1172         static internal void UpdateAsyncOperationContextWithStartTime(EventTraceActivity eventTraceActivity, long startTime)
1173         {
1174             if (OperationContext.Current != null)
1175             {
1176                 OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationStartTimeKey] = new EventTraceActivityTimeProperty(eventTraceActivity, startTime);
1177             }
1178         }
1179
1180         static internal void ExtractAsyncOperationStartTime(out EventTraceActivity eventTraceActivity, out long startTime)
1181         {
1182             EventTraceActivityTimeProperty data = null;
1183             eventTraceActivity = null;
1184             startTime = 0;
1185             if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue<EventTraceActivityTimeProperty>(TraceUtility.AsyncOperationStartTimeKey, out data))
1186             {
1187                 OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationStartTimeKey);
1188                 eventTraceActivity = data.EventTraceActivity;
1189                 startTime = data.StartTime;
1190             }
1191         }
1192
1193         internal class TracingAsyncCallbackState
1194         {
1195             object innerState;
1196             Guid activityId;
1197
1198             internal TracingAsyncCallbackState(object innerState)
1199             {
1200                 this.innerState = innerState;
1201                 this.activityId = DiagnosticTraceBase.ActivityId;
1202             }
1203
1204             internal object InnerState
1205             {
1206                 get { return this.innerState; }
1207             }
1208
1209             internal Guid ActivityId
1210             {
1211                 get { return this.activityId; }
1212             }
1213         }
1214
1215         internal static AsyncCallback WrapExecuteUserCodeAsyncCallback(AsyncCallback callback)
1216         {
1217             return (DiagnosticUtility.ShouldUseActivity && callback != null) ?
1218                 (new ExecuteUserCodeAsync(callback)).Callback
1219                 : callback;
1220         }
1221
1222         sealed class ExecuteUserCodeAsync
1223         {
1224             AsyncCallback callback;
1225
1226             public ExecuteUserCodeAsync(AsyncCallback callback)
1227             {
1228                 this.callback = callback;
1229             }
1230
1231             public AsyncCallback Callback
1232             {
1233                 get
1234                 {
1235                     return Fx.ThunkCallback(new AsyncCallback(this.ExecuteUserCode));
1236                 }
1237             }
1238
1239             void ExecuteUserCode(IAsyncResult result)
1240             {
1241                 using (ServiceModelActivity activity = ServiceModelActivity.CreateBoundedActivity())
1242                 {
1243                     ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityCallback), ActivityType.ExecuteUserCode);
1244                     this.callback(result);
1245                 }
1246             }
1247         }
1248
1249
1250         class EventTraceActivityTimeProperty
1251         {
1252             long startTime;
1253             EventTraceActivity eventTraceActivity;
1254
1255             public EventTraceActivityTimeProperty(EventTraceActivity eventTraceActivity, long startTime)
1256             {
1257                 this.eventTraceActivity = eventTraceActivity;
1258                 this.startTime = startTime;
1259             }
1260
1261             internal long StartTime
1262             {
1263                 get { return this.startTime; }
1264             }
1265             internal EventTraceActivity EventTraceActivity
1266             {
1267                 get { return this.eventTraceActivity; }
1268             }
1269         }
1270
1271
1272         internal static string GetRemoteEndpointAddressPort(Net.IPEndPoint iPEndPoint)
1273         {
1274             //We really don't want any exceptions out of TraceUtility.
1275             if (iPEndPoint != null)
1276             {
1277                 try
1278                 {
1279                     return iPEndPoint.Address.ToString() + ":" + iPEndPoint.Port;
1280                 }
1281                 catch (Exception exception)
1282                 {
1283                     if (Fx.IsFatal(exception))
1284                     {
1285                         throw;
1286                     }
1287                     //ignore and continue with all non-fatal exceptions.
1288                 }
1289             }
1290
1291             return string.Empty;
1292         }
1293
1294         internal static string GetRemoteEndpointAddressPort(RemoteEndpointMessageProperty remoteEndpointMessageProperty)
1295         {
1296             try
1297             {
1298                 if (remoteEndpointMessageProperty != null)
1299                 {
1300                     return remoteEndpointMessageProperty.Address + ":" + remoteEndpointMessageProperty.Port;
1301                 }
1302             }
1303             catch (Exception exception)
1304             {
1305                 if (Fx.IsFatal(exception))
1306                 {
1307                     throw;
1308                 }
1309                 //ignore and continue with all non-fatal exceptions.
1310             }
1311
1312             return string.Empty;
1313         }
1314     }
1315 }