//---------------------------------------------------------------------------- // Copyright (c) Microsoft Corporation. All rights reserved. //---------------------------------------------------------------------------- namespace System.ServiceModel.Diagnostics { using System.Diagnostics; using System.Reflection; using System.Runtime; using System.Runtime.CompilerServices; using System.Runtime.Diagnostics; using System.ServiceModel.Channels; using System.ServiceModel.Dispatcher; using System.Threading; using System.Security; using System.ServiceModel.Configuration; using System.ServiceModel.Activation; using System.Xml; using System.ServiceModel.Diagnostics.Application; using System.Globalization; using System.Collections.Generic; static class TraceUtility { const string ActivityIdKey = "ActivityId"; const string AsyncOperationActivityKey = "AsyncOperationActivity"; const string AsyncOperationStartTimeKey = "AsyncOperationStartTime"; static bool shouldPropagateActivity; static bool shouldPropagateActivityGlobal; static bool activityTracing; static bool messageFlowTracing; static bool messageFlowTracingOnly; static long messageNumber = 0; static Func> asyncCallbackGenerator; static SortedList traceCodes = new SortedList(382) { // Administration trace codes (TraceCode.Administration) { TraceCode.WmiPut, "WmiPut" }, // Diagnostic trace codes (TraceCode.Diagnostics) { TraceCode.AppDomainUnload, "AppDomainUnload" }, { TraceCode.EventLog, "EventLog" }, { TraceCode.ThrowingException, "ThrowingException" }, { TraceCode.TraceHandledException, "TraceHandledException" }, { TraceCode.UnhandledException, "UnhandledException" }, { TraceCode.FailedToAddAnActivityIdHeader, "FailedToAddAnActivityIdHeader" }, { TraceCode.FailedToReadAnActivityIdHeader, "FailedToReadAnActivityIdHeader" }, { TraceCode.FilterNotMatchedNodeQuotaExceeded, "FilterNotMatchedNodeQuotaExceeded" }, { TraceCode.MessageCountLimitExceeded, "MessageCountLimitExceeded" }, { TraceCode.DiagnosticsFailedMessageTrace, "DiagnosticsFailedMessageTrace" }, { TraceCode.MessageNotLoggedQuotaExceeded, "MessageNotLoggedQuotaExceeded" }, { TraceCode.TraceTruncatedQuotaExceeded, "TraceTruncatedQuotaExceeded" }, { TraceCode.ActivityBoundary, "ActivityBoundary" }, // Serialization trace codes (TraceCode.Serialization) { TraceCode.ElementIgnored, "" }, // shared by ServiceModel, need to investigate if should put this one in the SM section // Channels trace codes (TraceCode.Channels) { TraceCode.ConnectionAbandoned, "ConnectionAbandoned" }, { TraceCode.ConnectionPoolCloseException, "ConnectionPoolCloseException" }, { TraceCode.ConnectionPoolIdleTimeoutReached, "ConnectionPoolIdleTimeoutReached" }, { TraceCode.ConnectionPoolLeaseTimeoutReached, "ConnectionPoolLeaseTimeoutReached" }, { TraceCode.ConnectionPoolMaxOutboundConnectionsPerEndpointQuotaReached, "ConnectionPoolMaxOutboundConnectionsPerEndpointQuotaReached" }, { TraceCode.ServerMaxPooledConnectionsQuotaReached, "ServerMaxPooledConnectionsQuotaReached" }, { TraceCode.EndpointListenerClose, "EndpointListenerClose" }, { TraceCode.EndpointListenerOpen, "EndpointListenerOpen" }, { TraceCode.HttpResponseReceived, "HttpResponseReceived" }, { TraceCode.HttpChannelConcurrentReceiveQuotaReached, "HttpChannelConcurrentReceiveQuotaReached" }, { TraceCode.HttpChannelMessageReceiveFailed, "HttpChannelMessageReceiveFailed" }, { TraceCode.HttpChannelUnexpectedResponse, "HttpChannelUnexpectedResponse" }, { TraceCode.HttpChannelRequestAborted, "HttpChannelRequestAborted" }, { TraceCode.HttpChannelResponseAborted, "HttpChannelResponseAborted" }, { TraceCode.HttpsClientCertificateInvalid, "HttpsClientCertificateInvalid" }, { TraceCode.HttpsClientCertificateNotPresent, "HttpsClientCertificateNotPresent" }, { TraceCode.NamedPipeChannelMessageReceiveFailed, "NamedPipeChannelMessageReceiveFailed" }, { TraceCode.NamedPipeChannelMessageReceived, "NamedPipeChannelMessageReceived" }, { TraceCode.MessageReceived, "MessageReceived" }, { TraceCode.MessageSent, "MessageSent" }, { TraceCode.RequestChannelReplyReceived, "RequestChannelReplyReceived" }, { TraceCode.TcpChannelMessageReceiveFailed, "TcpChannelMessageReceiveFailed" }, { TraceCode.TcpChannelMessageReceived, "TcpChannelMessageReceived" }, { TraceCode.ConnectToIPEndpoint, "ConnectToIPEndpoint" }, { TraceCode.SocketConnectionCreate, "SocketConnectionCreate" }, { TraceCode.SocketConnectionClose, "SocketConnectionClose" }, { TraceCode.SocketConnectionAbort, "SocketConnectionAbort" }, { TraceCode.SocketConnectionAbortClose, "SocketConnectionAbortClose" }, { TraceCode.PipeConnectionAbort, "PipeConnectionAbort" }, { TraceCode.RequestContextAbort, "RequestContextAbort" }, { TraceCode.ChannelCreated, "ChannelCreated" }, { TraceCode.ChannelDisposed, "ChannelDisposed" }, { TraceCode.ListenerCreated, "ListenerCreated" }, { TraceCode.ListenerDisposed, "ListenerDisposed" }, { TraceCode.PrematureDatagramEof, "PrematureDatagramEof" }, { TraceCode.MaxPendingConnectionsReached, "MaxPendingConnectionsReached" }, { TraceCode.MaxAcceptedChannelsReached, "MaxAcceptedChannelsReached" }, { TraceCode.ChannelConnectionDropped, "ChannelConnectionDropped" }, { TraceCode.HttpAuthFailed, "HttpAuthFailed" }, { TraceCode.NoExistingTransportManager, "NoExistingTransportManager" }, { TraceCode.IncompatibleExistingTransportManager, "IncompatibleExistingTransportManager" }, { TraceCode.InitiatingNamedPipeConnection, "InitiatingNamedPipeConnection" }, { TraceCode.InitiatingTcpConnection, "InitiatingTcpConnection" }, { TraceCode.OpenedListener, "OpenedListener" }, { TraceCode.SslClientCertMissing, "SslClientCertMissing" }, { TraceCode.StreamSecurityUpgradeAccepted, "StreamSecurityUpgradeAccepted" }, { TraceCode.TcpConnectError, "TcpConnectError" }, { TraceCode.FailedAcceptFromPool, "FailedAcceptFromPool" }, { TraceCode.FailedPipeConnect, "FailedPipeConnect" }, { TraceCode.SystemTimeResolution, "SystemTimeResolution" }, { TraceCode.PeerNeighborCloseFailed, "PeerNeighborCloseFailed" }, { TraceCode.PeerNeighborClosingFailed, "PeerNeighborClosingFailed" }, { TraceCode.PeerNeighborNotAccepted, "PeerNeighborNotAccepted" }, { TraceCode.PeerNeighborNotFound, "PeerNeighborNotFound" }, { TraceCode.PeerNeighborOpenFailed, "PeerNeighborOpenFailed" }, { TraceCode.PeerNeighborStateChanged, "PeerNeighborStateChanged" }, { TraceCode.PeerNeighborStateChangeFailed, "PeerNeighborStateChangeFailed" }, { TraceCode.PeerNeighborMessageReceived, "PeerNeighborMessageReceived" }, { TraceCode.PeerNeighborManagerOffline, "PeerNeighborManagerOffline" }, { TraceCode.PeerNeighborManagerOnline, "PeerNeighborManagerOnline" }, { TraceCode.PeerChannelMessageReceived, "PeerChannelMessageReceived" }, { TraceCode.PeerChannelMessageSent, "PeerChannelMessageSent" }, { TraceCode.PeerNodeAddressChanged, "PeerNodeAddressChanged" }, { TraceCode.PeerNodeOpening, "PeerNodeOpening" }, { TraceCode.PeerNodeOpened, "PeerNodeOpened" }, { TraceCode.PeerNodeOpenFailed, "PeerNodeOpenFailed" }, { TraceCode.PeerNodeClosing, "PeerNodeClosing" }, { TraceCode.PeerNodeClosed, "PeerNodeClosed" }, { TraceCode.PeerFloodedMessageReceived, "PeerFloodedMessageReceived" }, { TraceCode.PeerFloodedMessageNotPropagated, "PeerFloodedMessageNotPropagated" }, { TraceCode.PeerFloodedMessageNotMatched, "PeerFloodedMessageNotMatched" }, { TraceCode.PnrpRegisteredAddresses, "PnrpRegisteredAddresses" }, { TraceCode.PnrpUnregisteredAddresses, "PnrpUnregisteredAddresses" }, { TraceCode.PnrpResolvedAddresses, "PnrpResolvedAddresses" }, { TraceCode.PnrpResolveException, "PnrpResolveException" }, { TraceCode.PeerReceiveMessageAuthenticationFailure, "PeerReceiveMessageAuthenticationFailure" }, { TraceCode.PeerNodeAuthenticationFailure, "PeerNodeAuthenticationFailure" }, { TraceCode.PeerNodeAuthenticationTimeout, "PeerNodeAuthenticationTimeout" }, { TraceCode.PeerFlooderReceiveMessageQuotaExceeded, "PeerFlooderReceiveMessageQuotaExceeded" }, { TraceCode.PeerServiceOpened, "PeerServiceOpened" }, { TraceCode.PeerMaintainerActivity, "PeerMaintainerActivity" }, { TraceCode.MsmqCannotPeekOnQueue, "MsmqCannotPeekOnQueue" }, { TraceCode.MsmqCannotReadQueues, "MsmqCannotReadQueues" }, { TraceCode.MsmqDatagramSent, "MsmqDatagramSent" }, { TraceCode.MsmqDatagramReceived, "MsmqDatagramReceived" }, { TraceCode.MsmqDetected, "MsmqDetected" }, { TraceCode.MsmqEnteredBatch, "MsmqEnteredBatch" }, { TraceCode.MsmqExpectedException, "MsmqExpectedException" }, { TraceCode.MsmqFoundBaseAddress, "MsmqFoundBaseAddress" }, { TraceCode.MsmqLeftBatch, "MsmqLeftBatch" }, { TraceCode.MsmqMatchedApplicationFound, "MsmqMatchedApplicationFound" }, { TraceCode.MsmqMessageDropped, "MsmqMessageDropped" }, { TraceCode.MsmqMessageLockedUnderTheTransaction, "MsmqMessageLockedUnderTheTransaction" }, { TraceCode.MsmqMessageRejected, "MsmqMessageRejected" }, { TraceCode.MsmqMoveOrDeleteAttemptFailed, "MsmqMoveOrDeleteAttemptFailed" }, { TraceCode.MsmqPoisonMessageMovedPoison, "MsmqPoisonMessageMovedPoison" }, { TraceCode.MsmqPoisonMessageMovedRetry, "MsmqPoisonMessageMovedRetry" }, { TraceCode.MsmqPoisonMessageRejected, "MsmqPoisonMessageRejected" }, { TraceCode.MsmqPoolFull, "MsmqPoolFull" }, { TraceCode.MsmqPotentiallyPoisonMessageDetected, "MsmqPotentiallyPoisonMessageDetected" }, { TraceCode.MsmqQueueClosed, "MsmqQueueClosed" }, { TraceCode.MsmqQueueOpened, "MsmqQueueOpened" }, { TraceCode.MsmqQueueTransactionalStatusUnknown, "MsmqQueueTransactionalStatusUnknown" }, { TraceCode.MsmqScanStarted, "MsmqScanStarted" }, { TraceCode.MsmqSessiongramReceived, "MsmqSessiongramReceived" }, { TraceCode.MsmqSessiongramSent, "MsmqSessiongramSent" }, { TraceCode.MsmqStartingApplication, "MsmqStartingApplication" }, { TraceCode.MsmqStartingService, "MsmqStartingService" }, { TraceCode.MsmqUnexpectedAcknowledgment, "MsmqUnexpectedAcknowledgment" }, { TraceCode.WsrmNegativeElapsedTimeDetected, "WsrmNegativeElapsedTimeDetected" }, { TraceCode.TcpTransferError, "TcpTransferError" }, { TraceCode.TcpConnectionResetError, "TcpConnectionResetError" }, { TraceCode.TcpConnectionTimedOut, "TcpConnectionTimedOut" }, // ComIntegration trace codes (TraceCode.ComIntegration) { TraceCode.ComIntegrationServiceHostStartingService, "ComIntegrationServiceHostStartingService" }, { TraceCode.ComIntegrationServiceHostStartedService, "ComIntegrationServiceHostStartedService" }, { TraceCode.ComIntegrationServiceHostCreatedServiceContract, "ComIntegrationServiceHostCreatedServiceContract" }, { TraceCode.ComIntegrationServiceHostStartedServiceDetails, "ComIntegrationServiceHostStartedServiceDetails" }, { TraceCode.ComIntegrationServiceHostCreatedServiceEndpoint, "ComIntegrationServiceHostCreatedServiceEndpoint" }, { TraceCode.ComIntegrationServiceHostStoppingService, "ComIntegrationServiceHostStoppingService" }, { TraceCode.ComIntegrationServiceHostStoppedService, "ComIntegrationServiceHostStoppedService" }, { TraceCode.ComIntegrationDllHostInitializerStarting, "ComIntegrationDllHostInitializerStarting" }, { TraceCode.ComIntegrationDllHostInitializerAddingHost, "ComIntegrationDllHostInitializerAddingHost" }, { TraceCode.ComIntegrationDllHostInitializerStarted, "ComIntegrationDllHostInitializerStarted" }, { TraceCode.ComIntegrationDllHostInitializerStopping, "ComIntegrationDllHostInitializerStopping" }, { TraceCode.ComIntegrationDllHostInitializerStopped, "ComIntegrationDllHostInitializerStopped" }, { TraceCode.ComIntegrationTLBImportStarting, "ComIntegrationTLBImportStarting" }, { TraceCode.ComIntegrationTLBImportFromAssembly, "ComIntegrationTLBImportFromAssembly" }, { TraceCode.ComIntegrationTLBImportFromTypelib, "ComIntegrationTLBImportFromTypelib" }, { TraceCode.ComIntegrationTLBImportConverterEvent, "ComIntegrationTLBImportConverterEvent" }, { TraceCode.ComIntegrationTLBImportFinished, "ComIntegrationTLBImportFinished" }, { TraceCode.ComIntegrationInstanceCreationRequest, "ComIntegrationInstanceCreationRequest" }, { TraceCode.ComIntegrationInstanceCreationSuccess, "ComIntegrationInstanceCreationSuccess" }, { TraceCode.ComIntegrationInstanceReleased, "ComIntegrationInstanceReleased" }, { TraceCode.ComIntegrationEnteringActivity, "ComIntegrationEnteringActivity" }, { TraceCode.ComIntegrationExecutingCall, "ComIntegrationExecutingCall" }, { TraceCode.ComIntegrationLeftActivity, "ComIntegrationLeftActivity" }, { TraceCode.ComIntegrationInvokingMethod, "ComIntegrationInvokingMethod" }, { TraceCode.ComIntegrationInvokedMethod, "ComIntegrationInvokedMethod" }, { TraceCode.ComIntegrationInvokingMethodNewTransaction, "ComIntegrationInvokingMethodNewTransaction" }, { TraceCode.ComIntegrationInvokingMethodContextTransaction, "ComIntegrationInvokingMethodContextTransaction" }, { TraceCode.ComIntegrationServiceMonikerParsed, "ComIntegrationServiceMonikerParsed" }, { TraceCode.ComIntegrationWsdlChannelBuilderLoaded, "ComIntegrationWsdlChannelBuilderLoaded" }, { TraceCode.ComIntegrationTypedChannelBuilderLoaded, "ComIntegrationTypedChannelBuilderLoaded" }, { TraceCode.ComIntegrationChannelCreated, "ComIntegrationChannelCreated" }, { TraceCode.ComIntegrationDispatchMethod, "ComIntegrationDispatchMethod" }, { TraceCode.ComIntegrationTxProxyTxCommitted, "ComIntegrationTxProxyTxCommitted" }, { TraceCode.ComIntegrationTxProxyTxAbortedByContext, "ComIntegrationTxProxyTxAbortedByContext" }, { TraceCode.ComIntegrationTxProxyTxAbortedByTM, "ComIntegrationTxProxyTxAbortedByTM" }, { TraceCode.ComIntegrationMexMonikerMetadataExchangeComplete, "ComIntegrationMexMonikerMetadataExchangeComplete" }, { TraceCode.ComIntegrationMexChannelBuilderLoaded, "ComIntegrationMexChannelBuilderLoaded" }, // Security trace codes (TraceCode.Security) { TraceCode.Security, "Security" }, { TraceCode.SecurityIdentityVerificationSuccess, "SecurityIdentityVerificationSuccess" }, { TraceCode.SecurityIdentityVerificationFailure, "SecurityIdentityVerificationFailure" }, { TraceCode.SecurityIdentityDeterminationSuccess, "SecurityIdentityDeterminationSuccess" }, { TraceCode.SecurityIdentityDeterminationFailure, "SecurityIdentityDeterminationFailure" }, { TraceCode.SecurityIdentityHostNameNormalizationFailure, "SecurityIdentityHostNameNormalizationFailure" }, { TraceCode.SecurityImpersonationSuccess, "SecurityImpersonationSuccess" }, { TraceCode.SecurityImpersonationFailure, "SecurityImpersonationFailure" }, { TraceCode.SecurityNegotiationProcessingFailure, "SecurityNegotiationProcessingFailure" }, { TraceCode.IssuanceTokenProviderRemovedCachedToken, "IssuanceTokenProviderRemovedCachedToken" }, { TraceCode.IssuanceTokenProviderUsingCachedToken, "IssuanceTokenProviderUsingCachedToken" }, { TraceCode.IssuanceTokenProviderBeginSecurityNegotiation, "IssuanceTokenProviderBeginSecurityNegotiation" }, { TraceCode.IssuanceTokenProviderEndSecurityNegotiation, "IssuanceTokenProviderEndSecurityNegotiation" }, { TraceCode.IssuanceTokenProviderRedirectApplied, "IssuanceTokenProviderRedirectApplied" }, { TraceCode.IssuanceTokenProviderServiceTokenCacheFull, "IssuanceTokenProviderServiceTokenCacheFull" }, { TraceCode.NegotiationTokenProviderAttached, "NegotiationTokenProviderAttached" }, { TraceCode.SpnegoClientNegotiationCompleted, "SpnegoClientNegotiationCompleted" }, { TraceCode.SpnegoServiceNegotiationCompleted, "SpnegoServiceNegotiationCompleted" }, { TraceCode.SpnegoClientNegotiation, "SpnegoClientNegotiation" }, { TraceCode.SpnegoServiceNegotiation, "SpnegoServiceNegotiation" }, { TraceCode.NegotiationAuthenticatorAttached, "NegotiationAuthenticatorAttached" }, { TraceCode.ServiceSecurityNegotiationCompleted, "ServiceSecurityNegotiationCompleted" }, { TraceCode.SecurityContextTokenCacheFull, "SecurityContextTokenCacheFull" }, { TraceCode.ExportSecurityChannelBindingEntry, "ExportSecurityChannelBindingEntry" }, { TraceCode.ExportSecurityChannelBindingExit, "ExportSecurityChannelBindingExit" }, { TraceCode.ImportSecurityChannelBindingEntry, "ImportSecurityChannelBindingEntry" }, { TraceCode.ImportSecurityChannelBindingExit, "ImportSecurityChannelBindingExit" }, { TraceCode.SecurityTokenProviderOpened, "SecurityTokenProviderOpened" }, { TraceCode.SecurityTokenProviderClosed, "SecurityTokenProviderClosed" }, { TraceCode.SecurityTokenAuthenticatorOpened, "SecurityTokenAuthenticatorOpened" }, { TraceCode.SecurityTokenAuthenticatorClosed, "SecurityTokenAuthenticatorClosed" }, { TraceCode.SecurityBindingOutgoingMessageSecured, "SecurityBindingOutgoingMessageSecured" }, { TraceCode.SecurityBindingIncomingMessageVerified, "SecurityBindingIncomingMessageVerified" }, { TraceCode.SecurityBindingSecureOutgoingMessageFailure, "SecurityBindingSecureOutgoingMessageFailure" }, { TraceCode.SecurityBindingVerifyIncomingMessageFailure, "SecurityBindingVerifyIncomingMessageFailure" }, { TraceCode.SecuritySpnToSidMappingFailure, "SecuritySpnToSidMappingFailure" }, { TraceCode.SecuritySessionRedirectApplied, "SecuritySessionRedirectApplied" }, { TraceCode.SecurityClientSessionCloseSent, "SecurityClientSessionCloseSent" }, { TraceCode.SecurityClientSessionCloseResponseSent, "SecurityClientSessionCloseResponseSent" }, { TraceCode.SecurityClientSessionCloseMessageReceived, "SecurityClientSessionCloseMessageReceived" }, { TraceCode.SecuritySessionKeyRenewalFaultReceived, "SecuritySessionKeyRenewalFaultReceived" }, { TraceCode.SecuritySessionAbortedFaultReceived, "SecuritySessionAbortedFaultReceived" }, { TraceCode.SecuritySessionClosedResponseReceived, "SecuritySessionClosedResponseReceived" }, { TraceCode.SecurityClientSessionPreviousKeyDiscarded, "SecurityClientSessionPreviousKeyDiscarded" }, { TraceCode.SecurityClientSessionKeyRenewed, "SecurityClientSessionKeyRenewed" }, { TraceCode.SecurityPendingServerSessionAdded, "SecurityPendingServerSessionAdded" }, { TraceCode.SecurityPendingServerSessionClosed, "SecurityPendingServerSessionClosed" }, { TraceCode.SecurityPendingServerSessionActivated, "SecurityPendingServerSessionActivated" }, { TraceCode.SecurityActiveServerSessionRemoved, "SecurityActiveServerSessionRemoved" }, { TraceCode.SecurityNewServerSessionKeyIssued, "SecurityNewServerSessionKeyIssued" }, { TraceCode.SecurityInactiveSessionFaulted, "SecurityInactiveSessionFaulted" }, { TraceCode.SecurityServerSessionKeyUpdated, "SecurityServerSessionKeyUpdated" }, { TraceCode.SecurityServerSessionCloseReceived, "SecurityServerSessionCloseReceived" }, { TraceCode.SecurityServerSessionRenewalFaultSent, "SecurityServerSessionRenewalFaultSent" }, { TraceCode.SecurityServerSessionAbortedFaultSent, "SecurityServerSessionAbortedFaultSent" }, { TraceCode.SecuritySessionCloseResponseSent, "SecuritySessionCloseResponseSent" }, { TraceCode.SecuritySessionServerCloseSent, "SecuritySessionServerCloseSent" }, { TraceCode.SecurityServerSessionCloseResponseReceived, "SecurityServerSessionCloseResponseReceived" }, { TraceCode.SecuritySessionRenewFaultSendFailure, "SecuritySessionRenewFaultSendFailure" }, { TraceCode.SecuritySessionAbortedFaultSendFailure, "SecuritySessionAbortedFaultSendFailure" }, { TraceCode.SecuritySessionClosedResponseSendFailure, "SecuritySessionClosedResponseSendFailure" }, { TraceCode.SecuritySessionServerCloseSendFailure, "SecuritySessionServerCloseSendFailure" }, { TraceCode.SecuritySessionRequestorStartOperation, "SecuritySessionRequestorStartOperation" }, { TraceCode.SecuritySessionRequestorOperationSuccess, "SecuritySessionRequestorOperationSuccess" }, { TraceCode.SecuritySessionRequestorOperationFailure, "SecuritySessionRequestorOperationFailure" }, { TraceCode.SecuritySessionResponderOperationFailure, "SecuritySessionResponderOperationFailure" }, { TraceCode.SecuritySessionDemuxFailure, "SecuritySessionDemuxFailure" }, { TraceCode.SecurityAuditWrittenSuccess, "SecurityAuditWrittenSuccess" }, { TraceCode.SecurityAuditWrittenFailure, "SecurityAuditWrittenFailure" }, // ServiceModel trace codes (TraceCode.ServiceModel) { TraceCode.AsyncCallbackThrewException, "AsyncCallbackThrewException" }, { TraceCode.CommunicationObjectAborted, "CommunicationObjectAborted" }, { TraceCode.CommunicationObjectAbortFailed, "CommunicationObjectAbortFailed" }, { TraceCode.CommunicationObjectCloseFailed, "CommunicationObjectCloseFailed" }, { TraceCode.CommunicationObjectOpenFailed, "CommunicationObjectOpenFailed" }, { TraceCode.CommunicationObjectClosing, "CommunicationObjectClosing" }, { TraceCode.CommunicationObjectClosed, "CommunicationObjectClosed" }, { TraceCode.CommunicationObjectCreated, "CommunicationObjectCreated" }, { TraceCode.CommunicationObjectDisposing, "CommunicationObjectDisposing" }, { TraceCode.CommunicationObjectFaultReason, "CommunicationObjectFaultReason" }, { TraceCode.CommunicationObjectFaulted, "CommunicationObjectFaulted" }, { TraceCode.CommunicationObjectOpening, "CommunicationObjectOpening" }, { TraceCode.CommunicationObjectOpened, "CommunicationObjectOpened" }, { TraceCode.DidNotUnderstandMessageHeader, "DidNotUnderstandMessageHeader" }, { TraceCode.UnderstoodMessageHeader, "UnderstoodMessageHeader" }, { TraceCode.MessageClosed, "MessageClosed" }, { TraceCode.MessageClosedAgain, "MessageClosedAgain" }, { TraceCode.MessageCopied, "MessageCopied" }, { TraceCode.MessageRead, "MessageRead" }, { TraceCode.MessageWritten, "MessageWritten" }, { TraceCode.BeginExecuteMethod, "BeginExecuteMethod" }, { TraceCode.ConfigurationIsReadOnly, "ConfigurationIsReadOnly" }, { TraceCode.ConfiguredExtensionTypeNotFound, "ConfiguredExtensionTypeNotFound" }, { TraceCode.EvaluationContextNotFound, "EvaluationContextNotFound" }, { TraceCode.EndExecuteMethod, "EndExecuteMethod" }, { TraceCode.ExtensionCollectionDoesNotExist, "ExtensionCollectionDoesNotExist" }, { TraceCode.ExtensionCollectionNameNotFound, "ExtensionCollectionNameNotFound" }, { TraceCode.ExtensionCollectionIsEmpty, "ExtensionCollectionIsEmpty" }, { TraceCode.ExtensionElementAlreadyExistsInCollection, "ExtensionElementAlreadyExistsInCollection" }, { TraceCode.ElementTypeDoesntMatchConfiguredType, "ElementTypeDoesntMatchConfiguredType" }, { TraceCode.ErrorInvokingUserCode, "ErrorInvokingUserCode" }, { TraceCode.GetBehaviorElement, "GetBehaviorElement" }, { TraceCode.GetCommonBehaviors, "GetCommonBehaviors" }, { TraceCode.GetConfiguredBinding, "GetConfiguredBinding" }, { TraceCode.GetChannelEndpointElement, "GetChannelEndpointElement" }, { TraceCode.GetConfigurationSection, "GetConfigurationSection" }, { TraceCode.GetDefaultConfiguredBinding, "GetDefaultConfiguredBinding" }, { TraceCode.GetServiceElement, "GetServiceElement" }, { TraceCode.MessageProcessingPaused, "MessageProcessingPaused" }, { TraceCode.ManualFlowThrottleLimitReached, "ManualFlowThrottleLimitReached" }, { TraceCode.OverridingDuplicateConfigurationKey, "OverridingDuplicateConfigurationKey" }, { TraceCode.RemoveBehavior, "RemoveBehavior" }, { TraceCode.ServiceChannelLifetime, "ServiceChannelLifetime" }, { TraceCode.ServiceHostCreation, "ServiceHostCreation" }, { TraceCode.ServiceHostBaseAddresses, "ServiceHostBaseAddresses" }, { TraceCode.ServiceHostTimeoutOnClose, "ServiceHostTimeoutOnClose" }, { TraceCode.ServiceHostFaulted, "ServiceHostFaulted" }, { TraceCode.ServiceHostErrorOnReleasePerformanceCounter, "ServiceHostErrorOnReleasePerformanceCounter" }, { TraceCode.ServiceThrottleLimitReached, "ServiceThrottleLimitReached" }, { TraceCode.ServiceOperationMissingReply, "ServiceOperationMissingReply" }, { TraceCode.ServiceOperationMissingReplyContext, "ServiceOperationMissingReplyContext" }, { TraceCode.ServiceOperationExceptionOnReply, "ServiceOperationExceptionOnReply" }, { TraceCode.SkipBehavior, "SkipBehavior" }, { TraceCode.TransportListen, "TransportListen" }, { TraceCode.UnhandledAction, "UnhandledAction" }, { TraceCode.PerformanceCounterFailedToLoad, "PerformanceCounterFailedToLoad" }, { TraceCode.PerformanceCountersFailed, "PerformanceCountersFailed" }, { TraceCode.PerformanceCountersFailedDuringUpdate, "PerformanceCountersFailedDuringUpdate" }, { TraceCode.PerformanceCountersFailedForService, "PerformanceCountersFailedForService" }, { TraceCode.PerformanceCountersFailedOnRelease, "PerformanceCountersFailedOnRelease" }, { TraceCode.WsmexNonCriticalWsdlExportError, "WsmexNonCriticalWsdlExportError" }, { TraceCode.WsmexNonCriticalWsdlImportError, "WsmexNonCriticalWsdlImportError" }, { TraceCode.FailedToOpenIncomingChannel, "FailedToOpenIncomingChannel" }, { TraceCode.UnhandledExceptionInUserOperation, "UnhandledExceptionInUserOperation" }, { TraceCode.DroppedAMessage, "DroppedAMessage" }, { TraceCode.CannotBeImportedInCurrentFormat, "CannotBeImportedInCurrentFormat" }, { TraceCode.GetConfiguredEndpoint, "GetConfiguredEndpoint" }, { TraceCode.GetDefaultConfiguredEndpoint, "GetDefaultConfiguredEndpoint" }, { TraceCode.ExtensionTypeNotFound, "ExtensionTypeNotFound" }, { TraceCode.DefaultEndpointsAdded, "DefaultEndpointsAdded" }, //ServiceModel Metadata codes { TraceCode.MetadataExchangeClientSendRequest, "MetadataExchangeClientSendRequest" }, { TraceCode.MetadataExchangeClientReceiveReply, "MetadataExchangeClientReceiveReply" }, { TraceCode.WarnHelpPageEnabledNoBaseAddress, "WarnHelpPageEnabledNoBaseAddress" }, // PortSharingtrace codes (TraceCode.PortSharing) { TraceCode.PortSharingClosed, "PortSharingClosed" }, { TraceCode.PortSharingDuplicatedPipe, "PortSharingDuplicatedPipe" }, { TraceCode.PortSharingDupHandleGranted, "PortSharingDupHandleGranted" }, { TraceCode.PortSharingDuplicatedSocket, "PortSharingDuplicatedSocket" }, { TraceCode.PortSharingListening, "PortSharingListening" }, { TraceCode.SharedManagerServiceEndpointNotExist, "SharedManagerServiceEndpointNotExist" }, //Indigo Tx trace codes (TraceCode.ServiceModelTransaction) { TraceCode.TxSourceTxScopeRequiredIsTransactedTransport, "TxSourceTxScopeRequiredIsTransactedTransport" }, { TraceCode.TxSourceTxScopeRequiredIsTransactionFlow, "TxSourceTxScopeRequiredIsTransactionFlow" }, { TraceCode.TxSourceTxScopeRequiredIsAttachedTransaction, "TxSourceTxScopeRequiredIsAttachedTransaction" }, { TraceCode.TxSourceTxScopeRequiredIsCreateNewTransaction, "TxSourceTxScopeRequiredIsCreateNewTransaction" }, { TraceCode.TxCompletionStatusCompletedForAutocomplete, "TxCompletionStatusCompletedForAutocomplete" }, { TraceCode.TxCompletionStatusCompletedForError, "TxCompletionStatusCompletedForError" }, { TraceCode.TxCompletionStatusCompletedForSetComplete, "TxCompletionStatusCompletedForSetComplete" }, { TraceCode.TxCompletionStatusCompletedForTACOSC, "TxCompletionStatusCompletedForTACOSC" }, { TraceCode.TxCompletionStatusCompletedForAsyncAbort, "TxCompletionStatusCompletedForAsyncAbort" }, { TraceCode.TxCompletionStatusRemainsAttached, "TxCompletionStatusRemainsAttached" }, { TraceCode.TxCompletionStatusAbortedOnSessionClose, "TxCompletionStatusAbortedOnSessionClose" }, { TraceCode.TxReleaseServiceInstanceOnCompletion, "TxReleaseServiceInstanceOnCompletion" }, { TraceCode.TxAsyncAbort, "TxAsyncAbort" }, { TraceCode.TxFailedToNegotiateOleTx, "TxFailedToNegotiateOleTx" }, { TraceCode.TxSourceTxScopeRequiredUsingExistingTransaction, "TxSourceTxScopeRequiredUsingExistingTransaction" }, //CfxGreen trace codes (TraceCode.NetFx35) { TraceCode.ActivatingMessageReceived, "ActivatingMessageReceived" }, { TraceCode.InstanceContextBoundToDurableInstance, "InstanceContextBoundToDurableInstance" }, { TraceCode.InstanceContextDetachedFromDurableInstance, "InstanceContextDetachedFromDurableInstance" }, { TraceCode.ContextChannelFactoryChannelCreated, "ContextChannelFactoryChannelCreated" }, { TraceCode.ContextChannelListenerChannelAccepted, "ContextChannelListenerChannelAccepted" }, { TraceCode.ContextProtocolContextAddedToMessage, "ContextProtocolContextAddedToMessage" }, { TraceCode.ContextProtocolContextRetrievedFromMessage, "ContextProtocolContextRetrievedFromMessage" }, { TraceCode.DICPInstanceContextCached, "DICPInstanceContextCached" }, { TraceCode.DICPInstanceContextRemovedFromCache, "DICPInstanceContextRemovedFromCache" }, { TraceCode.ServiceDurableInstanceDeleted, "ServiceDurableInstanceDeleted" }, { TraceCode.ServiceDurableInstanceDisposed, "ServiceDurableInstanceDisposed" }, { TraceCode.ServiceDurableInstanceLoaded, "ServiceDurableInstanceLoaded" }, { TraceCode.ServiceDurableInstanceSaved, "ServiceDurableInstanceSaved" }, { TraceCode.SqlPersistenceProviderSQLCallStart, "SqlPersistenceProviderSQLCallStart" }, { TraceCode.SqlPersistenceProviderSQLCallEnd, "SqlPersistenceProviderSQLCallEnd" }, { TraceCode.SqlPersistenceProviderOpenParameters, "SqlPersistenceProviderOpenParameters" }, { TraceCode.SyncContextSchedulerServiceTimerCancelled, "SyncContextSchedulerServiceTimerCancelled" }, { TraceCode.SyncContextSchedulerServiceTimerCreated, "SyncContextSchedulerServiceTimerCreated" }, { TraceCode.WorkflowDurableInstanceLoaded, "WorkflowDurableInstanceLoaded" }, { TraceCode.WorkflowDurableInstanceAborted, "WorkflowDurableInstanceAborted" }, { TraceCode.WorkflowDurableInstanceActivated, "WorkflowDurableInstanceActivated" }, { TraceCode.WorkflowOperationInvokerItemQueued, "WorkflowOperationInvokerItemQueued" }, { TraceCode.WorkflowRequestContextReplySent, "WorkflowRequestContextReplySent" }, { TraceCode.WorkflowRequestContextFaultSent, "WorkflowRequestContextFaultSent" }, { TraceCode.WorkflowServiceHostCreated, "WorkflowServiceHostCreated" }, { TraceCode.SyndicationReadFeedBegin, "SyndicationReadFeedBegin" }, { TraceCode.SyndicationReadFeedEnd, "SyndicationReadFeedEnd" }, { TraceCode.SyndicationReadItemBegin, "SyndicationReadItemBegin" }, { TraceCode.SyndicationReadItemEnd, "SyndicationReadItemEnd" }, { TraceCode.SyndicationWriteFeedBegin, "SyndicationWriteFeedBegin" }, { TraceCode.SyndicationWriteFeedEnd, "SyndicationWriteFeedEnd" }, { TraceCode.SyndicationWriteItemBegin, "SyndicationWriteItemBegin" }, { TraceCode.SyndicationWriteItemEnd, "SyndicationWriteItemEnd" }, { TraceCode.SyndicationProtocolElementIgnoredOnRead, "SyndicationProtocolElementIgnoredOnRead" }, { TraceCode.SyndicationProtocolElementIgnoredOnWrite, "SyndicationProtocolElementIgnoredOnWrite" }, { TraceCode.SyndicationProtocolElementInvalid, "SyndicationProtocolElementInvalid" }, { TraceCode.WebUnknownQueryParameterIgnored, "WebUnknownQueryParameterIgnored" }, { TraceCode.WebRequestMatchesOperation, "WebRequestMatchesOperation" }, { TraceCode.WebRequestDoesNotMatchOperations, "WebRequestDoesNotMatchOperations" }, { TraceCode.WebRequestRedirect, "WebRequestRedirect" }, { TraceCode.SyndicationReadServiceDocumentBegin, "SyndicationReadServiceDocumentBegin" }, { TraceCode.SyndicationReadServiceDocumentEnd, "SyndicationReadServiceDocumentEnd" }, { TraceCode.SyndicationReadCategoriesDocumentBegin, "SyndicationReadCategoriesDocumentBegin" }, { TraceCode.SyndicationReadCategoriesDocumentEnd, "SyndicationReadCategoriesDocumentEnd" }, { TraceCode.SyndicationWriteServiceDocumentBegin, "SyndicationWriteServiceDocumentBegin" }, { TraceCode.SyndicationWriteServiceDocumentEnd, "SyndicationWriteServiceDocumentEnd" }, { TraceCode.SyndicationWriteCategoriesDocumentBegin, "SyndicationWriteCategoriesDocumentBegin" }, { TraceCode.SyndicationWriteCategoriesDocumentEnd, "SyndicationWriteCategoriesDocumentEnd" }, { TraceCode.AutomaticFormatSelectedOperationDefault, "AutomaticFormatSelectedOperationDefault" }, { TraceCode.AutomaticFormatSelectedRequestBased, "AutomaticFormatSelectedRequestBased" }, { TraceCode.RequestFormatSelectedFromContentTypeMapper, "RequestFormatSelectedFromContentTypeMapper" }, { TraceCode.RequestFormatSelectedByEncoderDefaults, "RequestFormatSelectedByEncoderDefaults" }, { TraceCode.AddingResponseToOutputCache, "AddingResponseToOutputCache" }, { TraceCode.AddingAuthenticatedResponseToOutputCache, "AddingAuthenticatedResponseToOutputCache" }, { TraceCode.JsonpCallbackNameSet, "JsonpCallbackNameSet" }, }; public const string E2EActivityId = "E2EActivityId"; public const string TraceApplicationReference = "TraceApplicationReference"; public static InputQueue CreateInputQueue() where T : class { if (asyncCallbackGenerator == null) { asyncCallbackGenerator = new Func>(CallbackGenerator); } return new InputQueue(asyncCallbackGenerator) { DisposeItemCallback = value => { if (value is ICommunicationObject) { ((ICommunicationObject)value).Abort(); } } }; } static Action CallbackGenerator() { if (DiagnosticUtility.ShouldUseActivity) { ServiceModelActivity callbackActivity = ServiceModelActivity.Current; if (callbackActivity != null) { return delegate(AsyncCallback callback, IAsyncResult result) { using (ServiceModelActivity.BoundOperation(callbackActivity)) { callback(result); } }; } } return null; } static internal void AddActivityHeader(Message message) { try { ActivityIdHeader activityIdHeader = new ActivityIdHeader(TraceUtility.ExtractActivityId(message)); activityIdHeader.AddTo(message); } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToAddAnActivityIdHeader, SR.GetString(SR.TraceCodeFailedToAddAnActivityIdHeader), e, message); } } static internal void AddAmbientActivityToMessage(Message message) { try { ActivityIdHeader activityIdHeader = new ActivityIdHeader(DiagnosticTraceBase.ActivityId); activityIdHeader.AddTo(message); } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToAddAnActivityIdHeader, SR.GetString(SR.TraceCodeFailedToAddAnActivityIdHeader), e, message); } } static internal void CopyActivity(Message source, Message destination) { if (DiagnosticUtility.ShouldUseActivity) { TraceUtility.SetActivity(destination, TraceUtility.ExtractActivity(source)); } } internal static long GetUtcBasedDurationForTrace(long startTicks) { if (startTicks > 0) { TimeSpan elapsedTime = new TimeSpan(DateTime.UtcNow.Ticks - startTicks); return (long)elapsedTime.TotalMilliseconds; } return 0; } internal static ServiceModelActivity ExtractActivity(Message message) { ServiceModelActivity retval = null; if ((DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivityGlobal) && (message != null) && (message.State != MessageState.Closed)) { object property; if (message.Properties.TryGetValue(TraceUtility.ActivityIdKey, out property)) { retval = property as ServiceModelActivity; } } return retval; } internal static ServiceModelActivity ExtractActivity(RequestContext request) { try { return TraceUtility.ExtractActivity(request.RequestMessage); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } } return null; } internal static Guid ExtractActivityId(Message message) { if (TraceUtility.MessageFlowTracingOnly) { return ActivityIdHeader.ExtractActivityId(message); } ServiceModelActivity activity = ExtractActivity(message); return activity == null ? Guid.Empty : activity.Id; } internal static Guid GetReceivedActivityId(OperationContext operationContext) { object activityIdFromProprties; if (!operationContext.IncomingMessageProperties.TryGetValue(E2EActivityId, out activityIdFromProprties)) { return TraceUtility.ExtractActivityId(operationContext.IncomingMessage); } else { return (Guid)activityIdFromProprties; } } internal static ServiceModelActivity ExtractAndRemoveActivity(Message message) { ServiceModelActivity retval = TraceUtility.ExtractActivity(message); if (retval != null) { // If the property is just removed, the item is disposed and we don't want the thing // to be disposed of. message.Properties[TraceUtility.ActivityIdKey] = false; } return retval; } internal static void ProcessIncomingMessage(Message message, EventTraceActivity eventTraceActivity) { ServiceModelActivity activity = ServiceModelActivity.Current; if (activity != null && DiagnosticUtility.ShouldUseActivity) { ServiceModelActivity incomingActivity = TraceUtility.ExtractActivity(message); if (null != incomingActivity && incomingActivity.Id != activity.Id) { using (ServiceModelActivity.BoundOperation(incomingActivity)) { if (null != FxTrace.Trace) { FxTrace.Trace.TraceTransfer(activity.Id); } } } TraceUtility.SetActivity(message, activity); } TraceUtility.MessageFlowAtMessageReceived(message, null, eventTraceActivity, true); if (MessageLogger.LogMessagesAtServiceLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelReceiveReply | MessageLoggingSource.LastChance); } } internal static void ProcessOutgoingMessage(Message message, EventTraceActivity eventTraceActivity) { ServiceModelActivity activity = ServiceModelActivity.Current; if (DiagnosticUtility.ShouldUseActivity) { TraceUtility.SetActivity(message, activity); } if (TraceUtility.PropagateUserActivity || TraceUtility.ShouldPropagateActivity) { TraceUtility.AddAmbientActivityToMessage(message); } TraceUtility.MessageFlowAtMessageSent(message, eventTraceActivity); if (MessageLogger.LogMessagesAtServiceLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelSendRequest | MessageLoggingSource.LastChance); } } internal static void SetActivity(Message message, ServiceModelActivity activity) { if (DiagnosticUtility.ShouldUseActivity && message != null && message.State != MessageState.Closed) { message.Properties[TraceUtility.ActivityIdKey] = activity; } } internal static void TraceDroppedMessage(Message message, EndpointDispatcher dispatcher) { if (DiagnosticUtility.ShouldTraceInformation) { EndpointAddress endpointAddress = null; if (dispatcher != null) { endpointAddress = dispatcher.EndpointAddress; } TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.DroppedAMessage, SR.GetString(SR.TraceCodeDroppedAMessage), new MessageDroppedTraceRecord(message, endpointAddress)); } } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription) { TraceEvent(severity, traceCode, traceDescription, null, traceDescription, (Exception)null); } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData) { TraceEvent(severity, traceCode, traceDescription, extendedData, null, (Exception)null); } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source) { TraceEvent(severity, traceCode, traceDescription, null, source, (Exception)null); } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Exception exception) { TraceEvent(severity, traceCode, traceDescription, null, source, exception); } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Message message) { if (message == null) { TraceEvent(severity, traceCode, traceDescription, null, (Exception)null); } else { TraceEvent(severity, traceCode, traceDescription, message, message); } } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, object source, Message message) { Guid activityId = TraceUtility.ExtractActivityId(message); if (DiagnosticUtility.ShouldTrace(severity)) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), null, activityId, message); } } internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, Exception exception, Message message) { Guid activityId = TraceUtility.ExtractActivityId(message); if (DiagnosticUtility.ShouldTrace(severity)) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, new MessageTraceRecord(message), exception, activityId, null); } } internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source); } // These methods require a TraceRecord to be allocated, so we want them to show up on profiles if the caller didn't avoid // allocating the TraceRecord by using ShouldTrace. [MethodImpl(MethodImplOptions.NoInlining)] internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception) { if (DiagnosticUtility.ShouldTrace(severity)) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, source); } } [MethodImpl(MethodImplOptions.NoInlining)] internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Message message) { Guid activityId = TraceUtility.ExtractActivityId(message); if (DiagnosticUtility.ShouldTrace(severity)) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, activityId, source); } } internal static void TraceEventNoCheck(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, activityId, source); } [MethodImpl(MethodImplOptions.NoInlining)] internal static void TraceEvent(TraceEventType severity, int traceCode, string traceDescription, TraceRecord extendedData, object source, Exception exception, Guid activityId) { if (DiagnosticUtility.ShouldTrace(severity)) { DiagnosticUtility.DiagnosticTrace.TraceEvent(severity, traceCode, GenerateMsdnTraceCode(traceCode), traceDescription, extendedData, exception, activityId, source); } } static string GenerateMsdnTraceCode(int traceCode) { int group = (int)(traceCode & 0xFFFF0000); string terminatorUri = null; switch (group) { case TraceCode.Administration: terminatorUri = "System.ServiceModel.Administration"; break; case TraceCode.Channels: terminatorUri = "System.ServiceModel.Channels"; break; case TraceCode.ComIntegration: terminatorUri = "System.ServiceModel.ComIntegration"; break; case TraceCode.Diagnostics: terminatorUri = "System.ServiceModel.Diagnostics"; break; case TraceCode.PortSharing: terminatorUri = "System.ServiceModel.PortSharing"; break; case TraceCode.Security: terminatorUri = "System.ServiceModel.Security"; break; case TraceCode.Serialization: terminatorUri = "System.Runtime.Serialization"; break; case TraceCode.ServiceModel: case TraceCode.ServiceModelTransaction: terminatorUri = "System.ServiceModel"; break; default: terminatorUri = string.Empty; break; } Fx.Assert(traceCodes.ContainsKey(traceCode), string.Format(CultureInfo.InvariantCulture, "Unsupported trace code: Please add trace code 0x{0} to the SortedList TraceUtility.traceCodes in {1}", traceCode.ToString("X", CultureInfo.InvariantCulture), typeof(TraceUtility))); #if !MONO return LegacyDiagnosticTrace.GenerateMsdnTraceCode(terminatorUri, traceCodes[traceCode]); #else return ""; #endif } internal static Exception ThrowHelperError(Exception exception, Message message) { // If the message is closed, we won't get an activity Guid activityId = TraceUtility.ExtractActivityId(message); if (DiagnosticUtility.ShouldTraceError) { DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException), TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null); } return exception; } internal static Exception ThrowHelperError(Exception exception, Guid activityId, object source) { if (DiagnosticUtility.ShouldTraceError) { DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Error, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException), TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, source); } return exception; } internal static Exception ThrowHelperWarning(Exception exception, Message message) { if (DiagnosticUtility.ShouldTraceWarning) { Guid activityId = TraceUtility.ExtractActivityId(message); DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.ThrowingException, GenerateMsdnTraceCode(TraceCode.ThrowingException), TraceSR.GetString(TraceSR.ThrowingException), null, exception, activityId, null); } return exception; } internal static ArgumentException ThrowHelperArgument(string paramName, string message, Message msg) { return (ArgumentException)TraceUtility.ThrowHelperError(new ArgumentException(message, paramName), msg); } internal static ArgumentNullException ThrowHelperArgumentNull(string paramName, Message message) { return (ArgumentNullException)TraceUtility.ThrowHelperError(new ArgumentNullException(paramName), message); } internal static string CreateSourceString(object source) { return source.GetType().ToString() + "/" + source.GetHashCode().ToString(CultureInfo.CurrentCulture); } internal static void TraceHttpConnectionInformation(string localEndpoint, string remoteEndpoint, object source) { if (DiagnosticUtility.ShouldTraceInformation) { Dictionary values = new Dictionary(2) { { "LocalEndpoint", localEndpoint }, { "RemoteEndpoint", remoteEndpoint } }; TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.ConnectToIPEndpoint, SR.GetString(SR.TraceCodeConnectToIPEndpoint), new DictionaryTraceRecord(values), source, null); } } internal static void TraceUserCodeException(Exception e, MethodInfo method) { if (DiagnosticUtility.ShouldTraceWarning) { StringTraceRecord record = new StringTraceRecord("Comment", SR.GetString(SR.SFxUserCodeThrewException, method.DeclaringType.FullName, method.Name)); DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.UnhandledExceptionInUserOperation, GenerateMsdnTraceCode(TraceCode.UnhandledExceptionInUserOperation), SR.GetString(SR.TraceCodeUnhandledExceptionInUserOperation, method.DeclaringType.FullName, method.Name), record, e, null); } } static TraceUtility() { //Maintain the order of calls TraceUtility.SetEtwProviderId(); TraceUtility.SetEndToEndTracingFlags(); if (DiagnosticUtility.DiagnosticTrace != null) { DiagnosticTraceSource ts = (DiagnosticTraceSource)DiagnosticUtility.DiagnosticTrace.TraceSource; TraceUtility.shouldPropagateActivity = (ts.PropagateActivity || TraceUtility.shouldPropagateActivityGlobal); } } [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.", Safe = "Doesn't leak config section instance, just reads and stores bool values.")] [SecuritySafeCritical] static void SetEndToEndTracingFlags() { EndToEndTracingElement element = DiagnosticSection.UnsafeGetSection().EndToEndTracing; TraceUtility.shouldPropagateActivityGlobal = element.PropagateActivity; // if Sys.Diag trace is not enabled then the value is true if shouldPropagateActivityGlobal is true TraceUtility.shouldPropagateActivity = TraceUtility.shouldPropagateActivityGlobal || TraceUtility.shouldPropagateActivity; //Activity tracing is enabled by either of the flags (Sys.Diag trace source or E2E config element) DiagnosticUtility.ShouldUseActivity = (DiagnosticUtility.ShouldUseActivity || element.ActivityTracing); TraceUtility.activityTracing = DiagnosticUtility.ShouldUseActivity; TraceUtility.messageFlowTracing = element.MessageFlowTracing || TraceUtility.activityTracing; TraceUtility.messageFlowTracingOnly = element.MessageFlowTracing && !element.ActivityTracing; //Set the flag if activity tracing is enabled through the E2E config element as well DiagnosticUtility.TracingEnabled = (DiagnosticUtility.TracingEnabled || TraceUtility.activityTracing); } static public long RetrieveMessageNumber() { return Interlocked.Increment(ref TraceUtility.messageNumber); } static public bool PropagateUserActivity { get { return TraceUtility.ShouldPropagateActivity && TraceUtility.PropagateUserActivityCore; } } // Most of the time, shouldPropagateActivity will be false. // This property will rarely be executed as a result. static bool PropagateUserActivityCore { [MethodImpl(MethodImplOptions.NoInlining)] get { return !(DiagnosticUtility.TracingEnabled) && DiagnosticTraceBase.ActivityId != Guid.Empty; } } static internal string GetCallerInfo(OperationContext context) { if (context != null && context.IncomingMessageProperties != null) { object endpointMessageProperty; if (context.IncomingMessageProperties.TryGetValue(RemoteEndpointMessageProperty.Name, out endpointMessageProperty)) { RemoteEndpointMessageProperty endpoint = endpointMessageProperty as RemoteEndpointMessageProperty; if (endpoint != null) { return string.Format(CultureInfo.InvariantCulture, "{0}:{1}", endpoint.Address, endpoint.Port); } } } return "null"; } [Fx.Tag.SecurityNote(Critical = "Calls critical method DiagnosticSection.UnsafeGetSection.", Safe = "Doesn't leak config section instance, just reads and stores string values for Guid")] [SecuritySafeCritical] static internal void SetEtwProviderId() { // Get section should not trace as the ETW provider id is not set yet DiagnosticSection diagnostics = DiagnosticSection.UnsafeGetSectionNoTrace(); Guid etwProviderId = Guid.Empty; //set the Id in PT if specified in the config file. If not, ETW tracing is off. if (PartialTrustHelpers.HasEtwPermissions() || diagnostics.IsEtwProviderIdFromConfigFile()) { etwProviderId = Fx.CreateGuid(diagnostics.EtwProviderId); } System.Runtime.Diagnostics.EtwDiagnosticTrace.DefaultEtwProviderId = etwProviderId; } static internal void SetActivityId(MessageProperties properties) { Guid activityId; if ((null != properties) && properties.TryGetValue(TraceUtility.E2EActivityId, out activityId)) { DiagnosticTraceBase.ActivityId = activityId; } } static internal bool ShouldPropagateActivity { get { return TraceUtility.shouldPropagateActivity; } } static internal bool ShouldPropagateActivityGlobal { get { return TraceUtility.shouldPropagateActivityGlobal; } } static internal bool ActivityTracing { get { return TraceUtility.activityTracing; } } static internal bool MessageFlowTracing { get { return TraceUtility.messageFlowTracing; } } static internal bool MessageFlowTracingOnly { get { return TraceUtility.messageFlowTracingOnly; } } static internal void MessageFlowAtMessageSent(Message message, EventTraceActivity eventTraceActivity) { if (TraceUtility.MessageFlowTracing) { Guid activityId; Guid correlationId; bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId); if (TraceUtility.MessageFlowTracingOnly) { if (activityIdFound && activityId != DiagnosticTraceBase.ActivityId) { DiagnosticTraceBase.ActivityId = activityId; } } if (TD.MessageSentToTransportIsEnabled()) { TD.MessageSentToTransport(eventTraceActivity, correlationId); } } } static internal void MessageFlowAtMessageReceived(Message message, OperationContext context, EventTraceActivity eventTraceActivity, bool createNewActivityId) { if (TraceUtility.MessageFlowTracing) { Guid activityId; Guid correlationId; bool activityIdFound = ActivityIdHeader.ExtractActivityAndCorrelationId(message, out activityId, out correlationId); if (TraceUtility.MessageFlowTracingOnly) { if (createNewActivityId) { if (!activityIdFound) { activityId = Guid.NewGuid(); activityIdFound = true; } //message flow tracing only - start fresh DiagnosticTraceBase.ActivityId = Guid.Empty; } if (activityIdFound) { FxTrace.Trace.SetAndTraceTransfer(activityId, !createNewActivityId); message.Properties[TraceUtility.E2EActivityId] = Trace.CorrelationManager.ActivityId; } } if (TD.MessageReceivedFromTransportIsEnabled()) { if (context == null) { context = OperationContext.Current; } TD.MessageReceivedFromTransport(eventTraceActivity, correlationId, TraceUtility.GetAnnotation(context)); } } } internal static string GetAnnotation(OperationContext context) { object hostReference; if (context != null && null != context.IncomingMessage && (MessageState.Closed != context.IncomingMessage.State)) { if (!context.IncomingMessageProperties.TryGetValue(TraceApplicationReference, out hostReference)) { hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(context.Host); context.IncomingMessageProperties.Add(TraceApplicationReference, hostReference); } } else { hostReference = AspNetEnvironment.Current.GetAnnotationFromHost(null); } return (string)hostReference; } internal static void TransferFromTransport(Message message) { if (message != null && DiagnosticUtility.ShouldUseActivity) { Guid guid = Guid.Empty; // Only look if we are allowing user propagation if (TraceUtility.ShouldPropagateActivity) { guid = ActivityIdHeader.ExtractActivityId(message); } if (guid == Guid.Empty) { guid = Guid.NewGuid(); } ServiceModelActivity activity = null; bool emitStart = true; if (ServiceModelActivity.Current != null) { if ((ServiceModelActivity.Current.Id == guid) || (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction)) { activity = ServiceModelActivity.Current; emitStart = false; } else if (ServiceModelActivity.Current.PreviousActivity != null && ServiceModelActivity.Current.PreviousActivity.Id == guid) { activity = ServiceModelActivity.Current.PreviousActivity; emitStart = false; } } if (activity == null) { activity = ServiceModelActivity.CreateActivity(guid); } if (DiagnosticUtility.ShouldUseActivity) { if (emitStart) { if (null != FxTrace.Trace) { FxTrace.Trace.TraceTransfer(guid); } ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityProcessAction, message.Headers.Action), ActivityType.ProcessAction); } } message.Properties[TraceUtility.ActivityIdKey] = activity; } } static internal void UpdateAsyncOperationContextWithActivity(object activity) { if (OperationContext.Current != null && activity != null) { OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationActivityKey] = activity; } } static internal object ExtractAsyncOperationContextActivity() { object data = null; if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue(TraceUtility.AsyncOperationActivityKey, out data)) { OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationActivityKey); } return data; } static internal void UpdateAsyncOperationContextWithStartTime(EventTraceActivity eventTraceActivity, long startTime) { if (OperationContext.Current != null) { OperationContext.Current.OutgoingMessageProperties[TraceUtility.AsyncOperationStartTimeKey] = new EventTraceActivityTimeProperty(eventTraceActivity, startTime); } } static internal void ExtractAsyncOperationStartTime(out EventTraceActivity eventTraceActivity, out long startTime) { EventTraceActivityTimeProperty data = null; eventTraceActivity = null; startTime = 0; if (OperationContext.Current != null && OperationContext.Current.OutgoingMessageProperties.TryGetValue(TraceUtility.AsyncOperationStartTimeKey, out data)) { OperationContext.Current.OutgoingMessageProperties.Remove(TraceUtility.AsyncOperationStartTimeKey); eventTraceActivity = data.EventTraceActivity; startTime = data.StartTime; } } internal class TracingAsyncCallbackState { object innerState; Guid activityId; internal TracingAsyncCallbackState(object innerState) { this.innerState = innerState; this.activityId = DiagnosticTraceBase.ActivityId; } internal object InnerState { get { return this.innerState; } } internal Guid ActivityId { get { return this.activityId; } } } internal static AsyncCallback WrapExecuteUserCodeAsyncCallback(AsyncCallback callback) { return (DiagnosticUtility.ShouldUseActivity && callback != null) ? (new ExecuteUserCodeAsync(callback)).Callback : callback; } sealed class ExecuteUserCodeAsync { AsyncCallback callback; public ExecuteUserCodeAsync(AsyncCallback callback) { this.callback = callback; } public AsyncCallback Callback { get { return Fx.ThunkCallback(new AsyncCallback(this.ExecuteUserCode)); } } void ExecuteUserCode(IAsyncResult result) { using (ServiceModelActivity activity = ServiceModelActivity.CreateBoundedActivity()) { ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityCallback), ActivityType.ExecuteUserCode); this.callback(result); } } } class EventTraceActivityTimeProperty { long startTime; EventTraceActivity eventTraceActivity; public EventTraceActivityTimeProperty(EventTraceActivity eventTraceActivity, long startTime) { this.eventTraceActivity = eventTraceActivity; this.startTime = startTime; } internal long StartTime { get { return this.startTime; } } internal EventTraceActivity EventTraceActivity { get { return this.eventTraceActivity; } } } internal static string GetRemoteEndpointAddressPort(Net.IPEndPoint iPEndPoint) { //We really don't want any exceptions out of TraceUtility. if (iPEndPoint != null) { try { return iPEndPoint.Address.ToString() + ":" + iPEndPoint.Port; } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } //ignore and continue with all non-fatal exceptions. } } return string.Empty; } internal static string GetRemoteEndpointAddressPort(RemoteEndpointMessageProperty remoteEndpointMessageProperty) { try { if (remoteEndpointMessageProperty != null) { return remoteEndpointMessageProperty.Address + ":" + remoteEndpointMessageProperty.Port; } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } //ignore and continue with all non-fatal exceptions. } return string.Empty; } } }