static PerformanceCounters() { PerformanceCounterScope performanceCountersFromConfig = GetPerformanceCountersFromConfig(); if (performanceCountersFromConfig != PerformanceCounterScope.Off) { try { if (performanceCountersFromConfig == PerformanceCounterScope.Default) { performanceCountersFromConfig = OSEnvironmentHelper.IsVistaOrGreater ? PerformanceCounterScope.ServiceOnly : PerformanceCounterScope.Off; } scope = performanceCountersFromConfig; } catch (SecurityException exception) { scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceWarning) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); TraceUtility.TraceEvent(TraceEventType.Warning, 0x80038, System.ServiceModel.SR.GetString("PartialTrustPerformanceCountersNotEnabled")); } } } else { scope = PerformanceCounterScope.Off; } }
internal DefaultPerformanceCounters(ServiceHostBase serviceHost) { this.instanceName = DefaultPerformanceCounters.CreateFriendlyInstanceName(serviceHost); this.Counters = new PerformanceCounter[(int)PerfCounters.TotalCounters]; for (int i = 0; i < (int)PerfCounters.TotalCounters; i++) { try { PerformanceCounter counter = PerformanceCounters.GetDefaultPerformanceCounter(this.perfCounterNames[i], this.instanceName); if (counter != null) { this.Counters[i] = counter; } else { break; } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.PerformanceCountersFailedForService, SR.GetString(SR.TraceCodePerformanceCountersFailedForService), null, e); } break; } } }
internal OperationPerformanceCounters(string service, string contract, string operationName, string uri) : base(service, contract, operationName, uri) { this.Counters = new PerformanceCounter[15]; for (int i = 0; i < 15; i++) { PerformanceCounter operationPerformanceCounter = PerformanceCounters.GetOperationPerformanceCounter(OperationPerformanceCountersBase.perfCounterNames[i], base.instanceName); if (operationPerformanceCounter == null) { break; } try { operationPerformanceCounter.RawValue = 0L; this.Counters[i] = operationPerformanceCounter; } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x80038, System.ServiceModel.SR.GetString("TraceCodePerformanceCounterFailedToLoad"), null, exception); } break; } } }
static PerformanceCounters() { PerformanceCounterScope scope = GetPerformanceCountersFromConfig(); if (PerformanceCounterScope.Off != scope) { try { if (scope == PerformanceCounterScope.Default) { scope = OSEnvironmentHelper.IsVistaOrGreater ? PerformanceCounterScope.ServiceOnly : PerformanceCounterScope.Off; } PerformanceCounters.scope = scope; } catch (SecurityException securityException) { //switch off the counters - not supported in PT PerformanceCounters.scope = PerformanceCounterScope.Off; // not re-throwing on purpose DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning); if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(System.Diagnostics.TraceEventType.Warning, TraceCode.PerformanceCounterFailedToLoad, SR.GetString(SR.PartialTrustPerformanceCountersNotEnabled)); } } } else { PerformanceCounters.scope = PerformanceCounterScope.Off; } }
private static void LogInternal(MessageLogTraceRecord record) { PlainXmlWriter writer = new PlainXmlWriter(MaxMessageSize); try { record.WriteTo(writer); writer.Close(); TraceXPathNavigator data = writer.Navigator; if (((messageTraceSource != null) && !messageTraceSource.ShouldLogPii) || !LogKnownPii) { data.RemovePii(PiiHeadersPaths); if ((LogMessageBody && (record.Message != null)) && HasSecurityAction(record.Message)) { data.RemovePii(PiiBodyPaths); } } LogInternal(record.MessageLoggingSource, data); } catch (PlainXmlWriter.MaxSizeExceededException) { if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, 0x2000b, System.ServiceModel.SR.GetString("TraceCodeMessageNotLoggedQuotaExceeded"), record.Message); } } }
internal static Guid ExtractActivityId(Message message) { Guid empty = Guid.Empty; try { if (((message == null) || (message.State == MessageState.Closed)) || (message.Headers == null)) { return(empty); } int headerIndex = message.Headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics"); if (headerIndex < 0) { return(empty); } using (XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(headerIndex)) { empty = reader.ReadElementContentAsGuid(); } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x20007, System.ServiceModel.SR.GetString("TraceCodeFailedToReadAnActivityIdHeader"), null, exception); } } return(empty); }
static void IncrementLoggedMessagesCount(object data) { if (MessageLogger.numberOfMessagesToLog > 0) { lock (MessageLogger.syncObject) { if (MessageLogger.numberOfMessagesToLog > 0) { MessageLogger.numberOfMessagesToLog--; if (0 == MessageLogger.numberOfMessagesToLog) { if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.MessageCountLimitExceeded, SR.GetString(SR.TraceCodeMessageCountLimitExceeded), data); } } } } } lock (MessageLogger.syncObject) { if (!MessageLogger.lastWriteSucceeded) { MessageLogger.lastWriteSucceeded = true; } } }
static internal OperationPerformanceCountersBase CreateOperationCounters(string service, string contract, string operationName, string uri) { if (!CheckPermissions()) { return(null); } if (OSEnvironmentHelper.IsVistaOrGreater) { try { return(new OperationPerformanceCountersV2(service, contract, operationName, uri)); } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } PerformanceCounters.Scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.PerformanceCountersFailedForService, SR.GetString(SR.TraceCodePerformanceCountersFailedForService), null, e); } return(null); } } return(new OperationPerformanceCounters(service, contract, operationName, uri)); }
internal static void EnsureInitialized() { lock (MessageLogger.syncObject) { if (!MessageLogger.initialized && !MessageLogger.initializing) { try { Initialize(); } #pragma warning suppress 56500 // covered by FxCOP catch (SecurityException securityException) { // message logging is not support in PT, write the trace MessageLogger.inPartialTrust = true; if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.TraceHandledException, SR.GetString(SR.PartialTrustMessageLoggingNotEnabled), null, securityException); } // also write to event log LogNonFatalInitializationException( new SecurityException( SR.GetString(SR.PartialTrustMessageLoggingNotEnabled), securityException)); } MessageLogger.initialized = true; } } }
internal static ServicePerformanceCountersBase CreateServiceCounters(ServiceHostBase serviceHost) { if (OSEnvironmentHelper.IsVistaOrGreater) { try { ServicePerformanceCountersV2 sv = new ServicePerformanceCountersV2(serviceHost); EndpointPerformanceCountersV2.EnsureCounterSet(); OperationPerformanceCountersV2.EnsureCounterSet(); return(sv); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } PerformanceCounters.Scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x8003b, System.ServiceModel.SR.GetString("TraceCodePerformanceCountersFailedForService"), null, exception); } return(null); } } return(new ServicePerformanceCounters(serviceHost)); }
internal DefaultPerformanceCounters(ServiceHostBase serviceHost) { this.instanceName = CreateFriendlyInstanceName(serviceHost); this.Counters = new PerformanceCounter[1]; for (int i = 0; i < 1; i++) { try { PerformanceCounter defaultPerformanceCounter = PerformanceCounters.GetDefaultPerformanceCounter(this.perfCounterNames[i], this.instanceName); if (defaultPerformanceCounter != null) { this.Counters[i] = defaultPerformanceCounter; continue; } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x8003b, System.ServiceModel.SR.GetString("TraceCodePerformanceCountersFailedForService"), null, exception); } } break; } }
internal ServicePerformanceCounters(ServiceHostBase serviceHost) : base(serviceHost) { this.Counters = new PerformanceCounter[0x27]; for (int i = 0; i < 0x27; i++) { PerformanceCounter servicePerformanceCounter = PerformanceCounters.GetServicePerformanceCounter(ServicePerformanceCountersBase.perfCounterNames[i], this.InstanceName); if (servicePerformanceCounter == null) { break; } try { servicePerformanceCounter.RawValue = 0L; this.Counters[i] = servicePerformanceCounter; } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x8003b, System.ServiceModel.SR.GetString("TraceCodePerformanceCountersFailedForService"), null, exception); } break; } } }
internal EndpointPerformanceCounters(string service, string contract, string uri) : base(service, contract, uri) { this.Counters = new PerformanceCounter[(int)PerfCounters.TotalCounters]; for (int i = 0; i < (int)PerfCounters.TotalCounters; i++) { PerformanceCounter counter = PerformanceCounters.GetEndpointPerformanceCounter(perfCounterNames[i], this.instanceName); if (counter != null) { try { counter.RawValue = 0; this.Counters[i] = counter; } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.PerformanceCounterFailedToLoad, SR.GetString(SR.TraceCodePerformanceCounterFailedToLoad), null, e); } break; } } else { break; } } }
internal static void TracePerformanceCounterUpdateFailure(string instanceName, string perfCounterName) { if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x8003a, System.ServiceModel.SR.GetString("TraceCodePerformanceCountersFailedDuringUpdate", new object[] { perfCounterName + "::" + instanceName })); } }
internal override void WriteTo(XmlWriter xml) { if (((this.message != null) && (this.message.State != MessageState.Closed)) && (this.message.Headers != null)) { try { xml.WriteStartElement("MessageProperties"); if (this.message.Properties.Encoder != null) { xml.WriteElementString("Encoder", this.message.Properties.Encoder.ToString()); } xml.WriteElementString("AllowOutputBatching", this.message.Properties.AllowOutputBatching.ToString()); if ((this.message.Properties.Security != null) && (this.message.Properties.Security.ServiceSecurityContext != null)) { xml.WriteStartElement("Security"); xml.WriteElementString("IsAnonymous", this.message.Properties.Security.ServiceSecurityContext.IsAnonymous.ToString()); xml.WriteElementString("WindowsIdentityUsed", ((this.message.Properties.Security.ServiceSecurityContext.WindowsIdentity != null) && !string.IsNullOrEmpty(this.message.Properties.Security.ServiceSecurityContext.WindowsIdentity.Name)).ToString()); if (DiagnosticUtility.ShouldTraceVerbose) { xml.WriteStartElement("Claims"); AuthorizationContext authorizationContext = this.message.Properties.Security.ServiceSecurityContext.AuthorizationContext; for (int j = 0; j < authorizationContext.ClaimSets.Count; j++) { ClaimSet set = authorizationContext.ClaimSets[j]; xml.WriteStartElement("ClaimSet"); xml.WriteAttributeString("ClrType", base.XmlEncode(set.GetType().AssemblyQualifiedName)); for (int k = 0; k < set.Count; k++) { SecurityTraceRecordHelper.WriteClaim(xml, set[k]); } xml.WriteEndElement(); } xml.WriteEndElement(); } xml.WriteEndElement(); } if (this.message.Properties.Via != null) { xml.WriteElementString("Via", this.message.Properties.Via.ToString()); } xml.WriteEndElement(); xml.WriteStartElement("MessageHeaders"); for (int i = 0; i < this.message.Headers.Count; i++) { this.message.Headers.WriteHeader(i, xml); } xml.WriteEndElement(); } catch (CommunicationException exception) { if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, 0x2000a, System.ServiceModel.SR.GetString("TraceCodeDiagnosticsFailedMessageTrace"), (Exception)exception, this.message); } } } }
static void InitializeMessageTraceSource() { try { MessageLogger.attemptedTraceSourceInitialization = true; PiiTraceSource tempSource = new PiiTraceSource(MessageLogger.MessageTraceSourceName, DiagnosticUtility.EventSourceName); tempSource.Switch.Level = SourceLevels.Information; tempSource.Listeners.Remove(MessageLogger.DefaultTraceListenerName); if (tempSource.Listeners.Count > 0) { AppDomain.CurrentDomain.DomainUnload += new EventHandler(ExitOrUnloadEventHandler); AppDomain.CurrentDomain.ProcessExit += new EventHandler(ExitOrUnloadEventHandler); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(ExitOrUnloadEventHandler); } else { tempSource = null; } MessageLogger.messageTraceSource = tempSource; } catch (System.Configuration.ConfigurationErrorsException) { throw; } #pragma warning suppress 56500 // covered by FxCOP catch (SecurityException securityException) { // message logging is not support in PT, write the trace MessageLogger.inPartialTrust = true; if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.TraceHandledException, SR.GetString(SR.PartialTrustMessageLoggingNotEnabled), null, securityException); } // also write to event log LogNonFatalInitializationException( new SecurityException( SR.GetString(SR.PartialTrustMessageLoggingNotEnabled), securityException)); } catch (Exception e) { MessageLogger.messageTraceSource = null; if (Fx.IsFatal(e)) { throw; } LogNonFatalInitializationException(e); } }
static internal void TracePerformanceCounterUpdateFailure(string instanceName, string perfCounterName) { if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent( System.Diagnostics.TraceEventType.Error, TraceCode.PerformanceCountersFailedDuringUpdate, SR.GetString(SR.TraceCodePerformanceCountersFailedDuringUpdate, perfCounterName + "::" + instanceName)); } }
static bool MatchFilters(Message message, MessageLoggingSource source) { bool result = true; if (MessageLogger.FilterMessages && (source & MessageLoggingSource.Malformed) == 0) { result = false; List <XPathMessageFilter> filtersToRemove = new List <XPathMessageFilter>(); lock (MessageLogger.syncObject) { foreach (XPathMessageFilter filter in MessageLogger.Filters) { try { if (filter.Match(message)) { result = true; break; } } catch (FilterInvalidBodyAccessException) { filtersToRemove.Add(filter); } catch (MessageFilterException e) { if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.FilterNotMatchedNodeQuotaExceeded, SR.GetString(SR.TraceCodeFilterNotMatchedNodeQuotaExceeded), e, message); } } } foreach (XPathMessageFilter filter in filtersToRemove) { MessageLogger.Filters.Remove(filter); PlainXmlWriter writer = new PlainXmlWriter(); filter.WriteXPathTo(writer, null, ConfigurationStrings.Filter, null, true); DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging, (uint)System.Runtime.Diagnostics.EventLogEventId.RemovedBadFilter, writer.Navigator.ToString()); } if (MessageLogger.FilterCount == 0) { result = true; } } } return(result); }
private static bool MatchFilters(Message message, MessageLoggingSource source) { bool flag = true; if (FilterMessages && ((source & MessageLoggingSource.Malformed) == MessageLoggingSource.None)) { flag = false; List <XPathMessageFilter> list = new List <XPathMessageFilter>(); lock (syncObject) { foreach (XPathMessageFilter filter in Filters) { try { if (filter.Match(message)) { flag = true; break; } } catch (FilterInvalidBodyAccessException) { list.Add(filter); } catch (MessageFilterException exception) { if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, 0x20008, System.ServiceModel.SR.GetString("TraceCodeFilterNotMatchedNodeQuotaExceeded"), (Exception)exception, message); } } } foreach (XPathMessageFilter filter2 in list) { Filters.Remove(filter2); PlainXmlWriter writer = new PlainXmlWriter(); filter2.WriteXPathTo(writer, null, "filter", null, true); DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, EventLogCategory.MessageLogging, (EventLogEventId)(-1073610746), new string[] { writer.Navigator.ToString() }); } if (FilterCount == 0) { flag = true; } } } return(flag); }
private static void InitializeMessageTraceSource() { try { attemptedTraceSourceInitialization = true; PiiTraceSource source = new PiiTraceSource("System.ServiceModel.MessageLogging", "System.ServiceModel 4.0.0.0") { Switch = { Level = SourceLevels.Information } }; source.Listeners.Remove("Default"); if (source.Listeners.Count > 0) { AppDomain.CurrentDomain.DomainUnload += new EventHandler(MessageLogger.ExitOrUnloadEventHandler); AppDomain.CurrentDomain.ProcessExit += new EventHandler(MessageLogger.ExitOrUnloadEventHandler); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(MessageLogger.ExitOrUnloadEventHandler); } else { source = null; } messageTraceSource = source; } catch (ConfigurationErrorsException) { throw; } catch (SecurityException exception) { inPartialTrust = true; if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, 0x20004, System.ServiceModel.SR.GetString("PartialTrustMessageLoggingNotEnabled"), null, exception); } LogNonFatalInitializationException(new SecurityException(System.ServiceModel.SR.GetString("PartialTrustMessageLoggingNotEnabled"), exception)); } catch (Exception exception2) { messageTraceSource = null; if (Fx.IsFatal(exception2)) { throw; } LogNonFatalInitializationException(exception2); } }
/// <summary> /// Returns true if we're running in full trust. Otherwise turns off performance counters and returns false. /// </summary> private static bool CheckPermissions() { // At this time (.net 4.5), performance counters require Unrestricted permissions to be created. if (PartialTrustHelpers.AppDomainFullyTrusted) { return(true); } PerformanceCounters.Scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.PerformanceCountersFailedForService, SR.GetString(SR.PartialTrustPerformanceCountersNotEnabled)); } return(false); }
internal static bool ExtractActivityAndCorrelationId(Message message, out Guid activityId, out Guid correlationId) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message"); } activityId = Guid.Empty; correlationId = Guid.Empty; try { if (message.State != MessageState.Closed && message.Headers != null) { int index = message.Headers.FindHeader(DiagnosticStrings.ActivityId, DiagnosticStrings.DiagnosticsNamespace); // Check the state again, in case the message was closed after we found the header if (index >= 0) { using (XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(index)) { correlationId = Fx.CreateGuid(reader.GetAttribute("CorrelationId", null)); activityId = reader.ReadElementContentAsGuid(); return(activityId != Guid.Empty); } } } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToReadAnActivityIdHeader, SR.GetString(SR.TraceCodeFailedToReadAnActivityIdHeader), null, e); } } return(false); }
static internal ServicePerformanceCountersBase CreateServiceCounters(ServiceHostBase serviceHost) { if (!CheckPermissions()) { return(null); } if (OSEnvironmentHelper.IsVistaOrGreater) { try { EnsureCategoriesExistIfNeeded(); var counters = new ServicePerformanceCountersV2(serviceHost); // Workaround Sys.Diag.PerformanceData problem: // Ensure that all three categories are initialized so other processes can still // expose endpoint/operation perf counters event if this one doesn't EndpointPerformanceCountersV2.EnsureCounterSet(); OperationPerformanceCountersV2.EnsureCounterSet(); return(counters); } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } PerformanceCounters.Scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.PerformanceCountersFailedForService, SR.GetString(SR.TraceCodePerformanceCountersFailedForService), null, e); } return(null); } } return(new ServicePerformanceCounters(serviceHost)); }
internal static void EnsureInitialized() { lock (syncObject) { if (!initialized && !initializing) { try { Initialize(); } catch (SecurityException exception) { inPartialTrust = true; if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, 0x20004, System.ServiceModel.SR.GetString("PartialTrustMessageLoggingNotEnabled"), null, exception); } LogNonFatalInitializationException(new SecurityException(System.ServiceModel.SR.GetString("PartialTrustMessageLoggingNotEnabled"), exception)); } initialized = true; } } }
internal static bool ExtractActivityAndCorrelationId(Message message, out Guid activityId, out Guid correlationId) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message"); } activityId = Guid.Empty; correlationId = Guid.Empty; try { if ((message.State != MessageState.Closed) && (message.Headers != null)) { int headerIndex = message.Headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics"); if (headerIndex >= 0) { using (XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(headerIndex)) { correlationId = Fx.CreateGuid(reader.GetAttribute("CorrelationId", null)); activityId = reader.ReadElementContentAsGuid(); return(activityId != Guid.Empty); } } } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x20007, System.ServiceModel.SR.GetString("TraceCodeFailedToReadAnActivityIdHeader"), null, exception); } } return(false); }
static void LogInternal(MessageLogTraceRecord record) { Fx.Assert(null != record, "record cannot be null"); PlainXmlWriter xmlWriter = new PlainXmlWriter(MessageLogger.MaxMessageSize); try { record.WriteTo(xmlWriter); xmlWriter.Close(); TraceXPathNavigator navigator = xmlWriter.Navigator; if ((MessageLogger.messageTraceSource != null && !MessageLogger.messageTraceSource.ShouldLogPii) || !MessageLogger.LogKnownPii) { navigator.RemovePii(MessageLogger.PiiHeadersPaths); if (MessageLogger.LogMessageBody && null != record.Message) { if (HasSecurityAction(record.Message)) { navigator.RemovePii(MessageLogger.PiiBodyPaths); } } } LogInternal(record.MessageLoggingSource, navigator); } catch (PlainXmlWriter.MaxSizeExceededException) { if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.MessageNotLoggedQuotaExceeded, SR.GetString(SR.TraceCodeMessageNotLoggedQuotaExceeded), record.Message); } } }
internal static EndpointPerformanceCountersBase CreateEndpointCounters(string service, string contract, string uri) { if (OSEnvironmentHelper.IsVistaOrGreater) { try { return(new EndpointPerformanceCountersV2(service, contract, uri)); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } PerformanceCounters.Scope = PerformanceCounterScope.Off; if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, 0x8003b, System.ServiceModel.SR.GetString("TraceCodePerformanceCountersFailedForService"), null, exception); } return(null); } } return(new EndpointPerformanceCounters(service, contract, uri)); }
private static void IncrementLoggedMessagesCount(object data) { if (numberOfMessagesToLog > 0) { lock (syncObject) { if (numberOfMessagesToLog > 0) { numberOfMessagesToLog--; if ((numberOfMessagesToLog == 0) && DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, 0x20009, System.ServiceModel.SR.GetString("TraceCodeMessageCountLimitExceeded"), data); } } } } lock (syncObject) { if (!lastWriteSucceeded) { lastWriteSucceeded = true; } } }
internal static Guid ExtractActivityId(Message message) { Guid guid = Guid.Empty; try { if (message != null && message.State != MessageState.Closed && message.Headers != null) { int index = message.Headers.FindHeader(DiagnosticStrings.ActivityId, DiagnosticStrings.DiagnosticsNamespace); // Check the state again, in case the message was closed after we found the header if (index >= 0) { using (XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(index)) { guid = reader.ReadElementContentAsGuid(); } } } } #pragma warning suppress 56500 // covered by FxCOP catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (DiagnosticUtility.ShouldTraceError) { TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.FailedToReadAnActivityIdHeader, SR.GetString(SR.TraceCodeFailedToReadAnActivityIdHeader), null, e); } } return(guid); }
// If EnsureUniquePerformanceCounterInstanceName is enabled, PerformanceCountersBase.cs will be checking if instances // exist in each of these categories, so we need to ensure the categories all exist. This works around System.Diagnostics // calls using PerformanceCounterLib to cache which categories do/don't exist. private static void EnsureCategoriesExistIfNeeded() { if (categoriesExist || !ServiceModelAppSettings.EnsureUniquePerformanceCounterInstanceNames) { return; } OperationPerformanceCountersV2 operationCounter = null; EndpointPerformanceCountersV2 endpointCounter = null; ServicePerformanceCountersV2 serviceCounter = null; try { if (PerformanceCounterCategory.Exists(PerformanceCounterStrings.SERVICEMODELOPERATION.OperationPerfCounters) && PerformanceCounterCategory.Exists(PerformanceCounterStrings.SERVICEMODELENDPOINT.EndpointPerfCounters) && PerformanceCounterCategory.Exists(PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters)) { categoriesExist = true; return; } // Categories do not exist. Update PerformanceCounterLib's cache using dummy counters. const string dummyValue = "_WCF_Admin"; // Older operating systems (such as windows 7) report the category as not existing unless a counter instance // has been created in it. Create one instance in each of the categories to ensure they will exist in the cache // that System.Diagnostics calls use. ServiceHost dummyServiceHost = new ServiceHost(typeof(object), new Uri("http://" + dummyValue)); operationCounter = new OperationPerformanceCountersV2(dummyValue, dummyValue, dummyValue, dummyValue); endpointCounter = new EndpointPerformanceCountersV2(dummyValue, dummyValue, dummyValue); serviceCounter = new ServicePerformanceCountersV2(dummyServiceHost); // Throw away cached categories, then read from the categories to cause the cache to be repopulated. PerformanceCounter.CloseSharedResources(); PerformanceCounterCategory.Exists(dummyValue); } catch (UnauthorizedAccessException) { // Don't have permission to read performance counters. Trace a warning. if (DiagnosticUtility.ShouldTraceWarning) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.PerformanceCountersFailedForService, SR.GetString(SR.EnsureCategoriesExistFailedPermission)); } } catch { // Failed to ensure all of the categories exist. Catch the exception and try to create the counter anyway. } finally { // Delete the dummy counters, we don't need them anymore. if (operationCounter != null) { operationCounter.DeleteInstance(); } if (endpointCounter != null) { endpointCounter.DeleteInstance(); } if (serviceCounter != null) { serviceCounter.DeleteInstance(); } categoriesExist = true; } }