internal static void ProcessIncomingMessage(Message message, EventTraceActivity eventTraceActivity)
{
ServiceModelActivity activity = ServiceModelActivity.Current;
if (activity != null && DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity incomingActivity = TraceUtility.ExtractActivity(message);
if (null != incomingActivity && incomingActivity.Id != activity.Id)
{
using (ServiceModelActivity.BoundOperation(incomingActivity))
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(activity.Id);
}
}
}
TraceUtility.SetActivity(message, activity);
}
TraceUtility.MessageFlowAtMessageReceived(message, null, eventTraceActivity, true);
if (MessageLogger.LogMessagesAtServiceLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.ServiceLevelReceiveReply | MessageLoggingSource.LastChance);
}
}
static internal Activity BoundOperation(ServiceModelActivity activity)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return(null);
}
return(ServiceModelActivity.BoundOperation(activity, false));
}
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);
}
private static void DoCallback(AsyncCallback callback, IAsyncResult result)
{
if (result is TraceAsyncResult)
{
TraceAsyncResult result2 = result as TraceAsyncResult;
if (TraceUtility.MessageFlowTracingOnly)
{
Trace.CorrelationManager.ActivityId = result2.CallbackActivity.Id;
result2.CallbackActivity = null;
}
using (ServiceModelActivity.BoundOperation(result2.CallbackActivity))
{
callback(result);
}
}
}
private static void DoCallback(AsyncCallback callback, IAsyncResult result)
{
if (result is TraceAsyncResult)
{
TraceAsyncResult thisPtr = result as TraceAsyncResult;
Fx.Assert(thisPtr.CallbackActivity != null, "this shouldn't be hooked up if we don't have a CallbackActivity");
if (TraceUtility.MessageFlowTracingOnly)
{
thisPtr.CallbackActivity = null;
}
using (ServiceModelActivity.BoundOperation(thisPtr.CallbackActivity))
{
callback(result);
}
}
}
private static void LogMessageImpl(ref Message message, XmlReader reader, MessageLoggingSource source)
{
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(message) : null;
using (ServiceModelActivity.BoundOperation(activity))
{
if (ShouldLogMessages(source) && ((numberOfMessagesToLog > 0) || (numberOfMessagesToLog == -1)))
{
bool flag = ((source & MessageLoggingSource.LastChance) != MessageLoggingSource.None) || ((source & MessageLoggingSource.TransportSend) != MessageLoggingSource.None);
source &= ~MessageLoggingSource.LastChance;
if (((flag || (message is NullMessage)) || (message.Version.Addressing != AddressingVersion.None)) && (MatchFilters(message, source) && ((numberOfMessagesToLog == -1) || (numberOfMessagesToLog > 0))))
{
MessageLogTraceRecord record = new MessageLogTraceRecord(ref message, reader, source, LogMessageBody);
LogInternal(record);
}
}
}
}
internal static Action <AsyncCallback, IAsyncResult> CallbackGenerator()
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity callbackActivity = ServiceModelActivity.Current;
if (callbackActivity != null)
{
return(delegate(AsyncCallback callback, IAsyncResult result)
{
using (ServiceModelActivity.BoundOperation(callbackActivity))
{
callback(result);
}
});
}
}
return(null);
}
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);
}
static void LogMessageImpl(ref Message message, XmlReader reader, MessageLoggingSource source)
{
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(message) : null;
using (ServiceModelActivity.BoundOperation(activity))
{
if (ShouldLogMessages(source) && (MessageLogger.numberOfMessagesToLog > 0 || MessageLogger.numberOfMessagesToLog == MessageLogger.Unlimited))
{
bool lastChance = (source & MessageLoggingSource.LastChance) != 0 || (source & MessageLoggingSource.TransportSend) != 0;
source &= ~MessageLoggingSource.LastChance;
// MessageLogger doesn't log AddressingVersion.None in the encoder since we want to make sure we log
// as much of the message as possible. So let the Transport log later.
if ((lastChance || message is NullMessage || message.Version.Addressing != AddressingVersion.None) &&
MatchFilters(message, source))
{
if (MessageLogger.numberOfMessagesToLog == MessageLogger.Unlimited || MessageLogger.numberOfMessagesToLog > 0)
{
MessageLogTraceRecord record = new MessageLogTraceRecord(ref message, reader, source, MessageLogger.LogMessageBody);
LogInternal(record);
}
}
}
}
}
