|
//------------------------------------------------------------------------------
// <copyright file="TraceUtility.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Services.Diagnostics {
using System.Threading;
using System.Net;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Globalization;
using System.Xml.Serialization;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Collections.Generic;
internal static class Tracing {
private static bool tracingEnabled = true;
private static bool tracingInitialized;
private static bool appDomainShutdown;
private const string TraceSourceAsmx = "System.Web.Services.Asmx";
private static TraceSource asmxTraceSource;
private static object internalSyncObject;
private static object InternalSyncObject {
get {
if (internalSyncObject == null) {
object o = new Object();
Interlocked.CompareExchange(ref internalSyncObject, o, null);
}
return internalSyncObject;
}
}
internal static bool On {
get {
if (!tracingInitialized) {
InitializeLogging();
}
return tracingEnabled;
}
}
internal static bool IsVerbose {
get {
return ValidateSettings(Asmx, TraceEventType.Verbose);
}
}
internal static TraceSource Asmx {
get {
if (!tracingInitialized)
InitializeLogging();
if (!tracingEnabled)
return null;
return asmxTraceSource;
}
}
/// <devdoc>
/// <para>Sets up internal config settings for logging. (MUST be called under critsec) </para>
/// </devdoc>
private static void InitializeLogging() {
lock (InternalSyncObject) {
if (!tracingInitialized) {
bool loggingEnabled = false;
asmxTraceSource = new TraceSource(TraceSourceAsmx);
if (asmxTraceSource.Switch.ShouldTrace(TraceEventType.Critical)) {
loggingEnabled = true;
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(UnhandledExceptionHandler);
currentDomain.DomainUnload += new EventHandler(AppDomainUnloadEvent);
currentDomain.ProcessExit += new EventHandler(ProcessExitEvent);
}
tracingEnabled = loggingEnabled;
tracingInitialized = true;
}
}
}
private static void Close() {
if (asmxTraceSource != null) {
asmxTraceSource.Close();
}
}
/// <devdoc>
/// <para>Logs any unhandled exception through this event handler</para>
/// </devdoc>
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args) {
Exception e = (Exception)args.ExceptionObject;
ExceptionCatch(TraceEventType.Error, sender, "UnhandledExceptionHandler", e);
}
private static void ProcessExitEvent(object sender, EventArgs e) {
Close();
appDomainShutdown = true;
}
/// <devdoc>
/// <para>Called when the system is shutting down, used to prevent additional logging post-shutdown</para>
/// </devdoc>
private static void AppDomainUnloadEvent(object sender, EventArgs e) {
Close();
appDomainShutdown = true;
}
/// <devdoc>
/// <para>Confirms logging is enabled, given current logging settings</para>
/// </devdoc>
private static bool ValidateSettings(TraceSource traceSource, TraceEventType traceLevel) {
if (!tracingEnabled) {
return false;
}
if (!tracingInitialized) {
InitializeLogging();
}
if (traceSource == null || !traceSource.Switch.ShouldTrace(traceLevel)) {
return false;
}
if (appDomainShutdown) {
return false;
}
return true;
}
internal static void Information(string format, params object[] args) {
if (!ValidateSettings(Asmx, TraceEventType.Information))
return;
TraceEvent(TraceEventType.Information, Res.GetString( format, args));
}
static void TraceEvent(TraceEventType eventType, string format) {
Asmx.TraceEvent(eventType, 0, format);
}
internal static Exception ExceptionThrow(TraceMethod method, Exception e) {
return ExceptionThrow(TraceEventType.Error, method, e);
}
internal static Exception ExceptionThrow(TraceEventType eventType, TraceMethod method, Exception e) {
if (!ValidateSettings(Asmx, eventType))
return e;
TraceEvent(eventType, Res.GetString(Res.TraceExceptionThrown, method.ToString(), e.GetType(), e.Message));
StackTrace(eventType, e);
return e;
}
internal static Exception ExceptionCatch(TraceMethod method, Exception e) {
return ExceptionCatch(TraceEventType.Error, method, e);
}
internal static Exception ExceptionCatch(TraceEventType eventType, TraceMethod method, Exception e) {
if (!ValidateSettings(Asmx, eventType))
return e;
TraceEvent(eventType, Res.GetString(Res.TraceExceptionCought, method, e.GetType(), e.Message));
StackTrace(eventType, e);
return e;
}
internal static Exception ExceptionCatch(TraceEventType eventType, object target, string method, Exception e) {
if (!ValidateSettings(Asmx, eventType))
return e;
TraceEvent(eventType, Res.GetString(Res.TraceExceptionCought, TraceMethod.MethodId(target, method), e.GetType(), e.Message));
StackTrace(eventType, e);
return e;
}
internal static Exception ExceptionIgnore(TraceEventType eventType, TraceMethod method, Exception e) {
if (!ValidateSettings(Asmx, eventType))
return e;
TraceEvent(eventType, Res.GetString(Res.TraceExceptionIgnored, method, e.GetType(), e.Message));
StackTrace(eventType, e);
return e;
}
static void StackTrace(TraceEventType eventType, Exception e) {
if (IsVerbose && !string.IsNullOrEmpty(e.StackTrace)) {
TraceEvent(eventType, Res.GetString(Res.TraceExceptionDetails, e.ToString()));
}
}
internal static string TraceId(string id) {
return Res.GetString(id);
}
static string GetHostByAddress(string ipAddress) {
try {
return Dns.GetHostByAddress(ipAddress).HostName;
}
catch {
return null;
}
}
internal static List<string> Details(HttpRequest request) {
if (request == null)
return null;
List<string> requestDetails = null;
requestDetails = new List<string>();
requestDetails.Add(Res.GetString(Res.TraceUserHostAddress, request.UserHostAddress));
string hostName = request.UserHostAddress == request.UserHostName ? GetHostByAddress(request.UserHostAddress) : request.UserHostName;
if (!string.IsNullOrEmpty(hostName))
requestDetails.Add(Res.GetString(Res.TraceUserHostName, hostName));
requestDetails.Add(Res.GetString(Res.TraceUrl, request.HttpMethod, request.Url));
if (request.UrlReferrer != null)
requestDetails.Add(Res.GetString(Res.TraceUrlReferrer, request.UrlReferrer));
return requestDetails;
}
internal static void Enter(string callId, TraceMethod caller) {
Enter(callId, caller, null, null);
}
internal static void Enter(string callId, TraceMethod caller, List<string> details) {
Enter(callId, caller, null, details);
}
internal static void Enter(string callId, TraceMethod caller, TraceMethod callDetails) {
Enter(callId, caller, callDetails, null);
}
internal static void Enter(string callId, TraceMethod caller, TraceMethod callDetails, List<string> details) {
if (!ValidateSettings(Asmx, TraceEventType.Information))
return;
string trace = callDetails == null ? Res.GetString(Res.TraceCallEnter, callId, caller) : Res.GetString(Res.TraceCallEnterDetails, callId, caller, callDetails);
if (details != null && details.Count > 0) {
StringBuilder sb = new StringBuilder(trace);
foreach (string detail in details) {
sb.Append(Environment.NewLine);
sb.Append(" ");
sb.Append(detail);
}
trace = sb.ToString();
}
TraceEvent(TraceEventType.Information, trace);
}
internal static XmlDeserializationEvents GetDeserializationEvents() {
XmlDeserializationEvents events = new XmlDeserializationEvents();
events.OnUnknownElement = new XmlElementEventHandler(OnUnknownElement);
events.OnUnknownAttribute = new XmlAttributeEventHandler(OnUnknownAttribute);
return events;
}
internal static void Exit(string callId, TraceMethod caller) {
if (!ValidateSettings(Asmx, TraceEventType.Information))
return;
TraceEvent(TraceEventType.Information, Res.GetString(Res.TraceCallExit, callId, caller));
}
internal static void OnUnknownElement(object sender, XmlElementEventArgs e) {
if (!ValidateSettings(Asmx, TraceEventType.Warning))
return;
if (e.Element == null)
return;
string xml = RuntimeUtils.ElementString(e.Element);
string format = e.ExpectedElements == null ? Res.WebUnknownElement : e.ExpectedElements.Length == 0 ? Res.WebUnknownElement1 : Res.WebUnknownElement2;
TraceEvent(TraceEventType.Warning, Res.GetString(format, xml, e.ExpectedElements));
}
internal static void OnUnknownAttribute(object sender, XmlAttributeEventArgs e) {
if (!ValidateSettings(Asmx, TraceEventType.Warning))
return;
if (e.Attr == null)
return;
// ignore attributes from known namepsaces
if (RuntimeUtils.IsKnownNamespace(e.Attr.NamespaceURI))
return;
string format = e.ExpectedAttributes == null ? Res.WebUnknownAttribute : e.ExpectedAttributes.Length == 0 ? Res.WebUnknownAttribute2 : Res.WebUnknownAttribute3;
TraceEvent(TraceEventType.Warning, Res.GetString(format, e.Attr.Name, e.Attr.Value, e.ExpectedAttributes));
}
}
internal class TraceMethod {
object target;
string name;
object[] args;
string call;
internal TraceMethod(object target, string name, params object[] args) {
this.target = target;
this.name = name;
this.args = args;
}
public override string ToString() {
if (call == null)
call = CallString(this.target, this.name, this.args);
return call;
}
internal static string CallString(object target, string method, params object[] args) {
StringBuilder sb = new StringBuilder();
WriteObjectId(sb, target);
sb.Append(':');
sb.Append(':');
sb.Append(method);
sb.Append('(');
for (int i = 0; i < args.Length; i++) {
object o = args[i];
WriteObjectId(sb, o);
if (o != null) {
sb.Append('=');
WriteValue(sb, o);
}
if (i + 1 < args.Length) {
sb.Append(',');
sb.Append(' ');
}
}
sb.Append(')');
return sb.ToString();
}
internal static string MethodId(object target, string method) {
StringBuilder sb = new StringBuilder();
WriteObjectId(sb, target);
sb.Append(':');
sb.Append(':');
sb.Append(method);
return sb.ToString();
}
static void WriteObjectId(StringBuilder sb, object o) {
if (o == null) {
sb.Append("(null)");
}
else if (o is Type) {
Type type = (Type)o;
sb.Append(type.FullName);
if (!(type.IsAbstract && type.IsSealed)) {
sb.Append('#');
sb.Append(HashString(o));
}
}
else {
sb.Append(o.GetType().FullName);
sb.Append('#');
sb.Append(HashString(o));
}
}
static void WriteValue(StringBuilder sb, object o) {
if (o == null) {
return;
}
if (o is string) {
sb.Append('"');
sb.Append(o);
sb.Append('"');
}
else {
Type type = o.GetType();
if (type.IsArray) {
sb.Append('[');
sb.Append(((Array)o).Length);
sb.Append(']');
}
else {
string value = o.ToString();
if (type.FullName == value) {
sb.Append('.');
sb.Append('.');
}
else {
sb.Append(value);
}
}
}
}
static string HashString(object objectValue) {
if (objectValue == null) {
return "(null)";
}
else {
return objectValue.GetHashCode().ToString(NumberFormatInfo.InvariantInfo);
}
}
}
}
|