mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
531 lines
18 KiB
C#
531 lines
18 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Diagnostics
|
|
{
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Runtime.Remoting.Messaging;
|
|
using System.Threading;
|
|
using System.Globalization;
|
|
using System.Collections.Generic;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
using System.Runtime.Diagnostics;
|
|
|
|
|
|
class ServiceModelActivity : IDisposable
|
|
{
|
|
[ThreadStatic]
|
|
static ServiceModelActivity currentActivity;
|
|
|
|
static string[] ActivityTypeNames = new string[(int)ActivityType.NumItems];
|
|
|
|
ServiceModelActivity previousActivity = null;
|
|
static string activityBoundaryDescription = null;
|
|
ActivityState lastState = ActivityState.Unknown;
|
|
string name = null;
|
|
bool autoStop = false;
|
|
bool autoResume = false;
|
|
Guid activityId;
|
|
bool disposed = false;
|
|
bool isAsync = false;
|
|
int stopCount = 0;
|
|
const int AsyncStopCount = 2;
|
|
TransferActivity activity = null;
|
|
ActivityType activityType = ActivityType.Unknown;
|
|
|
|
static ServiceModelActivity()
|
|
{
|
|
ActivityTypeNames[(int)ActivityType.Unknown] = "Unknown";
|
|
ActivityTypeNames[(int)ActivityType.Close] = "Close";
|
|
ActivityTypeNames[(int)ActivityType.Construct] = "Construct";
|
|
ActivityTypeNames[(int)ActivityType.ExecuteUserCode] = "ExecuteUserCode";
|
|
ActivityTypeNames[(int)ActivityType.ListenAt] = "ListenAt";
|
|
ActivityTypeNames[(int)ActivityType.Open] = "Open";
|
|
ActivityTypeNames[(int)ActivityType.OpenClient] = "Open";
|
|
ActivityTypeNames[(int)ActivityType.ProcessMessage] = "ProcessMessage";
|
|
ActivityTypeNames[(int)ActivityType.ProcessAction] = "ProcessAction";
|
|
ActivityTypeNames[(int)ActivityType.ReceiveBytes] = "ReceiveBytes";
|
|
ActivityTypeNames[(int)ActivityType.SecuritySetup] = "SecuritySetup";
|
|
ActivityTypeNames[(int)ActivityType.TransferToComPlus] = "TransferToComPlus";
|
|
ActivityTypeNames[(int)ActivityType.WmiGetObject] = "WmiGetObject";
|
|
ActivityTypeNames[(int)ActivityType.WmiPutInstance] = "WmiPutInstance";
|
|
}
|
|
|
|
ServiceModelActivity(Guid activityId)
|
|
{
|
|
this.activityId = activityId;
|
|
this.previousActivity = ServiceModelActivity.Current;
|
|
}
|
|
|
|
static string ActivityBoundaryDescription
|
|
{
|
|
get
|
|
{
|
|
if (ServiceModelActivity.activityBoundaryDescription == null)
|
|
{
|
|
ServiceModelActivity.activityBoundaryDescription = TraceSR.GetString(TraceSR.ActivityBoundary);
|
|
}
|
|
return ServiceModelActivity.activityBoundaryDescription;
|
|
}
|
|
}
|
|
|
|
internal ActivityType ActivityType
|
|
{
|
|
get { return this.activityType; }
|
|
}
|
|
|
|
internal ServiceModelActivity PreviousActivity
|
|
{
|
|
get { return this.previousActivity; }
|
|
}
|
|
|
|
static internal Activity BoundOperation(ServiceModelActivity activity)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
return ServiceModelActivity.BoundOperation(activity, false);
|
|
}
|
|
|
|
static internal Activity BoundOperation(ServiceModelActivity activity, bool addTransfer)
|
|
{
|
|
return activity == null ? null : ServiceModelActivity.BoundOperationCore(activity, addTransfer);
|
|
}
|
|
|
|
static Activity BoundOperationCore(ServiceModelActivity activity, bool addTransfer)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
TransferActivity retval = null;
|
|
if (activity != null)
|
|
{
|
|
retval = TransferActivity.CreateActivity(activity.activityId, addTransfer);
|
|
if (retval != null)
|
|
{
|
|
retval.SetPreviousServiceModelActivity(ServiceModelActivity.Current);
|
|
}
|
|
ServiceModelActivity.Current = activity;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateActivity()
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
return ServiceModelActivity.CreateActivity(Guid.NewGuid(), true);
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateActivity(bool autoStop)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(Guid.NewGuid(), true);
|
|
if (activity != null)
|
|
{
|
|
activity.autoStop = autoStop;
|
|
}
|
|
return activity;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateActivity(bool autoStop, string activityName, ActivityType activityType)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(autoStop);
|
|
ServiceModelActivity.Start(activity, activityName, activityType);
|
|
return activity;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateAsyncActivity()
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(true);
|
|
if (activity != null)
|
|
{
|
|
activity.isAsync = true;
|
|
}
|
|
return activity;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateBoundedActivity()
|
|
{
|
|
return ServiceModelActivity.CreateBoundedActivity(false);
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateBoundedActivity(bool suspendCurrent)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity activityToSuspend = ServiceModelActivity.Current;
|
|
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(true);
|
|
if (retval != null)
|
|
{
|
|
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval, true);
|
|
retval.activity.SetPreviousServiceModelActivity(activityToSuspend);
|
|
if (suspendCurrent)
|
|
{
|
|
retval.autoResume = true;
|
|
}
|
|
}
|
|
if (suspendCurrent && activityToSuspend != null)
|
|
{
|
|
activityToSuspend.Suspend();
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateBoundedActivity(Guid activityId)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId, true);
|
|
if (retval != null)
|
|
{
|
|
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval, true);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateBoundedActivityWithTransferInOnly(Guid activityId)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId, true);
|
|
if (retval != null)
|
|
{
|
|
if (null != FxTrace.Trace)
|
|
{
|
|
FxTrace.Trace.TraceTransfer(activityId);
|
|
}
|
|
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateLightWeightAsyncActivity(Guid activityId)
|
|
{
|
|
return new ServiceModelActivity(activityId);
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateActivity(Guid activityId)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity retval = null;
|
|
if (activityId != Guid.Empty)
|
|
{
|
|
retval = new ServiceModelActivity(activityId);
|
|
}
|
|
if (retval != null)
|
|
{
|
|
ServiceModelActivity.Current = retval;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity CreateActivity(Guid activityId, bool autoStop)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId);
|
|
if (retval != null)
|
|
{
|
|
retval.autoStop = autoStop;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal static ServiceModelActivity Current
|
|
{
|
|
get { return ServiceModelActivity.currentActivity; }
|
|
private set { ServiceModelActivity.currentActivity = value; }
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (!this.disposed)
|
|
{
|
|
this.disposed = true;
|
|
try
|
|
{
|
|
if (this.activity != null)
|
|
{
|
|
this.activity.Dispose();
|
|
}
|
|
if (this.autoStop)
|
|
{
|
|
this.Stop();
|
|
}
|
|
if (this.autoResume &&
|
|
ServiceModelActivity.Current != null)
|
|
{
|
|
ServiceModelActivity.Current.Resume();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
ServiceModelActivity.Current = this.previousActivity;
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal Guid Id
|
|
{
|
|
get { return this.activityId; }
|
|
}
|
|
|
|
ActivityState LastState
|
|
{
|
|
get { return this.lastState; }
|
|
set { this.lastState = value; }
|
|
}
|
|
|
|
internal string Name
|
|
{
|
|
get { return this.name; }
|
|
set { this.name = value; }
|
|
}
|
|
|
|
internal void Resume()
|
|
{
|
|
if (this.LastState == ActivityState.Suspend)
|
|
{
|
|
this.LastState = ActivityState.Resume;
|
|
this.TraceMilestone(TraceEventType.Resume);
|
|
}
|
|
}
|
|
|
|
internal void Resume(string activityName)
|
|
{
|
|
if (string.IsNullOrEmpty(this.Name))
|
|
{
|
|
this.name = activityName;
|
|
}
|
|
this.Resume();
|
|
}
|
|
|
|
static internal void Start(ServiceModelActivity activity, string activityName, ActivityType activityType)
|
|
{
|
|
if (activity != null && activity.LastState == ActivityState.Unknown)
|
|
{
|
|
activity.LastState = ActivityState.Start;
|
|
activity.name = activityName;
|
|
activity.activityType = activityType;
|
|
activity.TraceMilestone(TraceEventType.Start);
|
|
}
|
|
}
|
|
|
|
internal void Stop()
|
|
{
|
|
int newStopCount = 0;
|
|
if (this.isAsync)
|
|
{
|
|
newStopCount = Interlocked.Increment(ref this.stopCount);
|
|
}
|
|
if (this.LastState != ActivityState.Stop &&
|
|
(!this.isAsync || (this.isAsync && newStopCount >= ServiceModelActivity.AsyncStopCount)))
|
|
{
|
|
this.LastState = ActivityState.Stop;
|
|
this.TraceMilestone(TraceEventType.Stop);
|
|
}
|
|
}
|
|
|
|
static internal void Stop(ServiceModelActivity activity)
|
|
{
|
|
if (activity != null)
|
|
{
|
|
activity.Stop();
|
|
}
|
|
}
|
|
|
|
internal void Suspend()
|
|
{
|
|
if (this.LastState != ActivityState.Stop)
|
|
{
|
|
this.LastState = ActivityState.Suspend;
|
|
this.TraceMilestone(TraceEventType.Suspend);
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return this.Id.ToString();
|
|
}
|
|
|
|
void TraceMilestone(TraceEventType type)
|
|
{
|
|
if (string.IsNullOrEmpty(this.Name))
|
|
{
|
|
if (null != FxTrace.Trace)
|
|
{
|
|
CallEtwMileStoneEvent(type, null);
|
|
}
|
|
if (null != DiagnosticUtility.DiagnosticTrace)
|
|
{
|
|
TraceUtility.TraceEventNoCheck(type, TraceCode.ActivityBoundary, ServiceModelActivity.ActivityBoundaryDescription, null, ServiceModelActivity.ActivityBoundaryDescription, (Exception)null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (null != FxTrace.Trace)
|
|
{
|
|
Dictionary<string, string> values = new Dictionary<string, string>(2);
|
|
values["ActivityName"] = this.Name;
|
|
values["ActivityType"] = ServiceModelActivity.ActivityTypeNames[(int)this.activityType];
|
|
using (DiagnosticUtility.ShouldUseActivity && Guid.Empty == activityId ? null : Activity.CreateActivity(this.Id))
|
|
{
|
|
CallEtwMileStoneEvent(type, new DictionaryTraceRecord(values));
|
|
}
|
|
}
|
|
if (null != DiagnosticUtility.DiagnosticTrace)
|
|
{
|
|
Dictionary<string, string> values = new Dictionary<string, string>(2);
|
|
values["ActivityName"] = this.Name;
|
|
values["ActivityType"] = ServiceModelActivity.ActivityTypeNames[(int)this.activityType];
|
|
TraceUtility.TraceEventNoCheck(type, TraceCode.ActivityBoundary, ServiceModelActivity.ActivityBoundaryDescription, new DictionaryTraceRecord(values), null, null, this.Id);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CallEtwMileStoneEvent(TraceEventType type, DictionaryTraceRecord record)
|
|
{
|
|
switch (type)
|
|
{
|
|
case TraceEventType.Start:
|
|
|
|
if (TD.StartSignpostEventIsEnabled())
|
|
{
|
|
TD.StartSignpostEvent(record);
|
|
}
|
|
break;
|
|
case TraceEventType.Stop:
|
|
if (TD.StopSignpostEventIsEnabled())
|
|
{
|
|
TD.StopSignpostEvent(record);
|
|
}
|
|
break;
|
|
case TraceEventType.Suspend:
|
|
if (TD.SuspendSignpostEventIsEnabled())
|
|
{
|
|
TD.SuspendSignpostEvent(record);
|
|
}
|
|
break;
|
|
case TraceEventType.Resume:
|
|
if (TD.ResumeSignpostEventIsEnabled())
|
|
{
|
|
TD.ResumeSignpostEvent(record);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
enum ActivityState
|
|
{
|
|
Unknown,
|
|
Start,
|
|
Suspend,
|
|
Resume,
|
|
Stop,
|
|
}
|
|
|
|
class TransferActivity : Activity
|
|
{
|
|
bool addTransfer = false;
|
|
bool changeCurrentServiceModelActivity = false;
|
|
ServiceModelActivity previousActivity = null;
|
|
|
|
TransferActivity(Guid activityId, Guid parentId)
|
|
: base(activityId, parentId)
|
|
{
|
|
}
|
|
|
|
internal static TransferActivity CreateActivity(Guid activityId, bool addTransfer)
|
|
{
|
|
if (!DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
return null;
|
|
}
|
|
TransferActivity retval = null;
|
|
if (DiagnosticUtility.TracingEnabled && activityId != Guid.Empty)
|
|
{
|
|
Guid currentActivityId = DiagnosticTraceBase.ActivityId;
|
|
if (activityId != currentActivityId)
|
|
{
|
|
if (addTransfer)
|
|
{
|
|
if (null != FxTrace.Trace)
|
|
{
|
|
FxTrace.Trace.TraceTransfer(activityId);
|
|
}
|
|
}
|
|
TransferActivity activity = new TransferActivity(activityId, currentActivityId);
|
|
activity.addTransfer = addTransfer;
|
|
retval = activity;
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
internal void SetPreviousServiceModelActivity(ServiceModelActivity previous)
|
|
{
|
|
this.previousActivity = previous;
|
|
this.changeCurrentServiceModelActivity = true;
|
|
}
|
|
|
|
public override void Dispose()
|
|
{
|
|
try
|
|
{
|
|
if (addTransfer)
|
|
{
|
|
// Make sure that we are transferring from our AID to the
|
|
// parent. It is possible for someone else to change the ambient
|
|
// in user code (MB 49318).
|
|
using (Activity.CreateActivity(this.Id))
|
|
{
|
|
if (null != FxTrace.Trace)
|
|
{
|
|
FxTrace.Trace.TraceTransfer(this.parentId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (this.changeCurrentServiceModelActivity)
|
|
{
|
|
ServiceModelActivity.Current = this.previousActivity;
|
|
}
|
|
base.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|