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.GetProperty(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.SetProperty(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.SetProperty(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 } 1316