526 lines
22 KiB
C#
526 lines
22 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="TraceSource.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Threading;
|
|
using System.Configuration;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
namespace System.Diagnostics {
|
|
public class TraceSource {
|
|
private static List<WeakReference> tracesources = new List<WeakReference>();
|
|
private static int s_LastCollectionCount;
|
|
|
|
private volatile SourceSwitch internalSwitch;
|
|
private volatile TraceListenerCollection listeners;
|
|
private StringDictionary attributes;
|
|
private SourceLevels switchLevel;
|
|
private volatile string sourceName;
|
|
internal volatile bool _initCalled = false; // Whether we've called Initialize already.
|
|
|
|
public TraceSource(string name)
|
|
: this(name, SourceLevels.Off) {
|
|
}
|
|
|
|
public TraceSource(string name, SourceLevels defaultLevel) {
|
|
if (name == null)
|
|
throw new ArgumentNullException("name");
|
|
if (name.Length == 0)
|
|
throw new ArgumentException("name");
|
|
|
|
sourceName = name;
|
|
switchLevel = defaultLevel;
|
|
|
|
// Delay load config to avoid perf (and working set) issues in retail
|
|
|
|
// Add a weakreference to this source and cleanup invalid references
|
|
lock(tracesources) {
|
|
_pruneCachedTraceSources();
|
|
tracesources.Add(new WeakReference(this));
|
|
}
|
|
}
|
|
|
|
private static void _pruneCachedTraceSources() {
|
|
lock (tracesources) {
|
|
if (s_LastCollectionCount != GC.CollectionCount(2)) {
|
|
List<WeakReference> buffer = new List<WeakReference>(tracesources.Count);
|
|
for (int i = 0; i < tracesources.Count; i++) {
|
|
TraceSource tracesource = ((TraceSource)tracesources[i].Target);
|
|
if (tracesource != null) {
|
|
buffer.Add(tracesources[i]);
|
|
}
|
|
}
|
|
if (buffer.Count < tracesources.Count) {
|
|
tracesources.Clear();
|
|
tracesources.AddRange(buffer);
|
|
tracesources.TrimExcess();
|
|
}
|
|
s_LastCollectionCount = GC.CollectionCount(2);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Initialize() {
|
|
if (!_initCalled) {
|
|
lock(this) {
|
|
if (_initCalled)
|
|
return;
|
|
|
|
#if CONFIGURATION_DEP
|
|
SourceElementsCollection sourceElements = DiagnosticsConfiguration.Sources;
|
|
|
|
if (sourceElements != null) {
|
|
SourceElement sourceElement = sourceElements[sourceName];
|
|
if (sourceElement != null) {
|
|
if (!String.IsNullOrEmpty(sourceElement.SwitchName)) {
|
|
CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName);
|
|
}
|
|
else {
|
|
CreateSwitch(sourceElement.SwitchType, sourceName);
|
|
|
|
if (!String.IsNullOrEmpty(sourceElement.SwitchValue))
|
|
internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue);
|
|
}
|
|
|
|
listeners = sourceElement.Listeners.GetRuntimeObject();
|
|
|
|
attributes = new StringDictionary();
|
|
TraceUtils.VerifyAttributes(sourceElement.Attributes, GetSupportedAttributes(), this);
|
|
attributes.ReplaceHashtable(sourceElement.Attributes);
|
|
}
|
|
else
|
|
NoConfigInit();
|
|
}
|
|
else
|
|
#endif
|
|
NoConfigInit();
|
|
|
|
_initCalled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void NoConfigInit() {
|
|
internalSwitch = new SourceSwitch(sourceName, switchLevel.ToString());
|
|
listeners = new TraceListenerCollection();
|
|
listeners.Add(new DefaultTraceListener());
|
|
attributes = null;
|
|
}
|
|
|
|
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
|
|
public void Close() {
|
|
// No need to call Initialize()
|
|
if (listeners != null) {
|
|
// Use global lock
|
|
lock (TraceInternal.critSec) {
|
|
foreach (TraceListener listener in listeners) {
|
|
listener.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Flush() {
|
|
// No need to call Initialize()
|
|
if (listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
lock (TraceInternal.critSec) {
|
|
foreach (TraceListener listener in listeners) {
|
|
listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
foreach (TraceListener listener in listeners) {
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual protected internal string[] GetSupportedAttributes() {
|
|
return null;
|
|
}
|
|
|
|
internal static void RefreshAll() {
|
|
lock (tracesources) {
|
|
_pruneCachedTraceSources();
|
|
for (int i=0; i<tracesources.Count; i++) {
|
|
TraceSource tracesource = ((TraceSource) tracesources[i].Target);
|
|
if (tracesource != null) {
|
|
tracesource.Refresh();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void Refresh() {
|
|
if (!_initCalled) {
|
|
Initialize();
|
|
return;
|
|
}
|
|
|
|
#if CONFIGURATION_DEP
|
|
SourceElementsCollection sources = DiagnosticsConfiguration.Sources;
|
|
|
|
if (sources != null) {
|
|
SourceElement sourceElement = sources[Name];
|
|
if (sourceElement != null) {
|
|
|
|
// first check if the type changed
|
|
if ((String.IsNullOrEmpty(sourceElement.SwitchType) && internalSwitch.GetType() != typeof(SourceSwitch)) ||
|
|
(sourceElement.SwitchType != internalSwitch.GetType().AssemblyQualifiedName)) {
|
|
|
|
if (!String.IsNullOrEmpty(sourceElement.SwitchName)) {
|
|
CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName);
|
|
}
|
|
else {
|
|
CreateSwitch(sourceElement.SwitchType, Name);
|
|
|
|
if (!String.IsNullOrEmpty(sourceElement.SwitchValue))
|
|
internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue);
|
|
}
|
|
}
|
|
else if (!String.IsNullOrEmpty(sourceElement.SwitchName)) {
|
|
// create a new switch if the name changed, otherwise just refresh.
|
|
if (sourceElement.SwitchName != internalSwitch.DisplayName)
|
|
CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName);
|
|
else
|
|
internalSwitch.Refresh();
|
|
}
|
|
else {
|
|
// the switchValue changed. Just update our internalSwitch.
|
|
if (!String.IsNullOrEmpty(sourceElement.SwitchValue))
|
|
internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue);
|
|
else
|
|
internalSwitch.Level = SourceLevels.Off;
|
|
}
|
|
|
|
TraceListenerCollection newListenerCollection = new TraceListenerCollection();
|
|
foreach (ListenerElement listenerElement in sourceElement.Listeners) {
|
|
TraceListener listener = listeners[listenerElement.Name];
|
|
if (listener != null) {
|
|
newListenerCollection.Add(listenerElement.RefreshRuntimeObject(listener));
|
|
}
|
|
else {
|
|
newListenerCollection.Add(listenerElement.GetRuntimeObject());
|
|
}
|
|
}
|
|
|
|
TraceUtils.VerifyAttributes(sourceElement.Attributes, GetSupportedAttributes(), this);
|
|
|
|
attributes = new StringDictionary();
|
|
attributes.ReplaceHashtable(sourceElement.Attributes);
|
|
|
|
listeners = newListenerCollection;
|
|
}
|
|
else {
|
|
// there was no config, so clear whatever we have.
|
|
internalSwitch.Level = switchLevel;
|
|
listeners.Clear();
|
|
attributes = null;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceEvent(TraceEventType eventType, int id) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(eventType) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceEvent(manager, Name, eventType, id);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceEvent(manager, Name, eventType, id);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceEvent(manager, Name, eventType, id);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceEvent(TraceEventType eventType, int id, string message) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(eventType) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceEvent(manager, Name, eventType, id, message);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceEvent(manager, Name, eventType, id, message);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceEvent(manager, Name, eventType, id, message);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceEvent(TraceEventType eventType, int id, string format, params object[] args) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(eventType) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceEvent(manager, Name, eventType, id, format, args);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceEvent(manager, Name, eventType, id, format, args);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceEvent(manager, Name, eventType, id, format, args);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceData(TraceEventType eventType, int id, object data) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(eventType) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceData(TraceEventType eventType, int id, params object[] data) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(eventType) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceData(manager, Name, eventType, id, data);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceInformation(string message) { // eventType= TraceEventType.Info, id=0
|
|
// No need to call Initialize()
|
|
TraceEvent(TraceEventType.Information, 0, message, null);
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceInformation(string format, params object[] args) {
|
|
// No need to call Initialize()
|
|
TraceEvent(TraceEventType.Information, 0, format, args);
|
|
}
|
|
|
|
[Conditional("TRACE")]
|
|
public void TraceTransfer(int id, string message, Guid relatedActivityId) {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
TraceEventCache manager = new TraceEventCache();
|
|
|
|
if (internalSwitch.ShouldTrace(TraceEventType.Transfer) && listeners != null) {
|
|
if (TraceInternal.UseGlobalLock) {
|
|
// we lock on the same object that Trace does because we're writing to the same Listeners.
|
|
lock (TraceInternal.critSec) {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
listener.TraceTransfer(manager, Name, id, message, relatedActivityId);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i=0; i<listeners.Count; i++) {
|
|
TraceListener listener = listeners[i];
|
|
if (!listener.IsThreadSafe) {
|
|
lock (listener) {
|
|
listener.TraceTransfer(manager, Name, id, message, relatedActivityId);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
else {
|
|
listener.TraceTransfer(manager, Name, id, message, relatedActivityId);
|
|
if (Trace.AutoFlush) listener.Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CreateSwitch(string typename, string name) {
|
|
if (!String.IsNullOrEmpty(typename))
|
|
internalSwitch = (SourceSwitch) TraceUtils.GetRuntimeObject(typename, typeof(SourceSwitch), name);
|
|
else
|
|
internalSwitch = new SourceSwitch(name, switchLevel.ToString());
|
|
}
|
|
|
|
public StringDictionary Attributes {
|
|
get {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
if (attributes == null)
|
|
attributes = new StringDictionary();
|
|
|
|
return attributes;
|
|
}
|
|
}
|
|
|
|
public string Name {
|
|
get {
|
|
return sourceName;
|
|
}
|
|
}
|
|
|
|
public TraceListenerCollection Listeners {
|
|
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
|
|
get {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
return listeners;
|
|
}
|
|
}
|
|
|
|
public SourceSwitch Switch {
|
|
// No need for security demand here. SourceSwitch.set_Level is protected already.
|
|
get {
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
return internalSwitch;
|
|
}
|
|
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
|
|
set {
|
|
if (value == null)
|
|
throw new ArgumentNullException("Switch");
|
|
|
|
// Ensure that config is loaded
|
|
Initialize();
|
|
|
|
internalSwitch = value;
|
|
}
|
|
}
|
|
}
|
|
}
|