private void GetActivityInfo(ref ServiceModelActivity activity, ref Activity boundOperation)
 {
     if (TraceUtility.MessageFlowTracingOnly)
     {
         if (OperationContext.Current != null)
         {
             Guid receivedActivityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
             if (receivedActivityId != Guid.Empty)
             {
                 DiagnosticTrace.ActivityId = receivedActivityId;
             }
         }
     }
     else if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
     {
         object obj2 = TraceUtility.ExtractAsyncOperationContextActivity();
         if (obj2 != null)
         {
             if (DiagnosticUtility.ShouldUseActivity)
             {
                 activity = obj2 as ServiceModelActivity;
                 boundOperation = ServiceModelActivity.BoundOperation(activity, true);
             }
             else if (TraceUtility.ShouldPropagateActivity && (obj2 is Guid))
             {
                 Guid activityId = (Guid) obj2;
                 boundOperation = Activity.CreateActivity(activityId);
             }
         }
     }
 }
示例#2
0
 static internal void Stop(ServiceModelActivity activity)
 {
     if (activity != null)
     {
         activity.Stop();
     }
 }
示例#3
0
 public void Dispose()
 {
     if (!_disposed)
     {
         _disposed = true;
         try
         {
             if (_activity != null)
             {
                 _activity.Dispose();
             }
             if (_autoStop)
             {
                 this.Stop();
             }
             if (_autoResume &&
                 ServiceModelActivity.Current != null)
             {
                 ServiceModelActivity.Current.Resume();
             }
         }
         finally
         {
             ServiceModelActivity.Current = _previousActivity;
             GC.SuppressFinalize(this);
         }
     }
 }
 internal static void CreateActivityInfo(ref ServiceModelActivity activity, ref Activity boundActivity)
 {
     if (DiagnosticUtility.ShouldUseActivity)
     {
         activity = ServiceModelActivity.CreateAsyncActivity();
         TraceUtility.UpdateAsyncOperationContextWithActivity(activity);
         boundActivity = ServiceModelActivity.BoundOperation(activity, true);
     }
     else if (TraceUtility.MessageFlowTracingOnly)
     {
         Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
         if (activityId != Guid.Empty)
         {
             DiagnosticTraceBase.ActivityId = activityId;
         }
     }
     else if (TraceUtility.ShouldPropagateActivity)
     {
         //Message flow tracing only scenarios use a light-weight ActivityID management logic
         Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
         if (activityId != Guid.Empty)
         {
             boundActivity = Activity.CreateActivity(activityId);
         }
         TraceUtility.UpdateAsyncOperationContextWithActivity(activityId);
     }
 }
示例#5
0
        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);
            }
        }
 private void CreateActivityInfo(ref ServiceModelActivity activity, ref Activity boundActivity)
 {
     if (DiagnosticUtility.ShouldUseActivity)
     {
         activity = ServiceModelActivity.CreateAsyncActivity();
         TraceUtility.UpdateAsyncOperationContextWithActivity(activity);
         boundActivity = ServiceModelActivity.BoundOperation(activity, true);
     }
     else if (TraceUtility.MessageFlowTracingOnly)
     {
         Guid receivedActivityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
         if (receivedActivityId != Guid.Empty)
         {
             DiagnosticTrace.ActivityId = receivedActivityId;
         }
     }
     else if (TraceUtility.ShouldPropagateActivity)
     {
         Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
         if (activityId != Guid.Empty)
         {
             boundActivity = Activity.CreateActivity(activityId);
         }
         TraceUtility.UpdateAsyncOperationContextWithActivity(activityId);
     }
 }
示例#7
0
 internal static void SetActivity(Message message, ServiceModelActivity activity)
 {
     if (DiagnosticUtility.ShouldUseActivity && message != null && message.State != MessageState.Closed)
     {
         message.Properties[TraceUtility.ActivityIdKey] = activity;
     }
 }
示例#8
0
 static internal Activity BoundOperation(ServiceModelActivity activity)
 {
     if (!DiagnosticUtility.ShouldUseActivity)
     {
         return(null);
     }
     return(ServiceModelActivity.BoundOperation(activity, false));
 }
 static internal Activity BoundOperation(ServiceModelActivity activity)
 {
     if (!DiagnosticUtility.ShouldUseActivity)
     {
         return null;
     }
     return ServiceModelActivity.BoundOperation(activity, false);
 }
 internal static Activity BoundOperation(ServiceModelActivity activity, bool addTransfer)
 {
     if (activity != null)
     {
         return BoundOperationCore(activity, addTransfer);
     }
     return null;
 }
示例#11
0
 private void ExecuteUserCode(IAsyncResult result)
 {
     using (ServiceModelActivity activity = ServiceModelActivity.CreateBoundedActivity())
     {
         ServiceModelActivity.Start(activity, SR.ActivityCallback, ActivityType.ExecuteUserCode);
         this._callback(result);
     }
 }
 public TracingConnection(IConnection connection, bool inheritCurrentActivity) : base(connection)
 {
     this.activity = inheritCurrentActivity ? ServiceModelActivity.CreateActivity(DiagnosticTrace.ActivityId, false) : ServiceModelActivity.CreateActivity();
     if ((DiagnosticUtility.ShouldUseActivity && !inheritCurrentActivity) && (FxTrace.Trace != null))
     {
         FxTrace.Trace.TraceTransfer(this.activity.Id);
     }
 }
示例#13
0
 internal static Activity BoundOperation(ServiceModelActivity activity, bool addTransfer)
 {
     if (activity != null)
     {
         return(BoundOperationCore(activity, addTransfer));
     }
     return(null);
 }
示例#14
0
 internal static ServiceModelActivity CreateActivity()
 {
     if (!DiagnosticUtility.ShouldUseActivity)
     {
         return(null);
     }
     return(ServiceModelActivity.CreateActivity(Guid.NewGuid(), true));
 }
示例#15
0
 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;
     }
 }
 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);
     }
 }
示例#17
0
 internal static void Start(ServiceModelActivity activity, string activityName, System.ServiceModel.Diagnostics.ActivityType activityType)
 {
     if ((activity != null) && (activity.LastState == ActivityState.Unknown))
     {
         activity.LastState    = ActivityState.Start;
         activity.name         = activityName;
         activity.activityType = activityType;
         activity.TraceMilestone(TraceEventType.Start);
     }
 }
示例#18
0
        internal static Guid ExtractActivityId(Message message)
        {
            if (TraceUtility.MessageFlowTracingOnly)
            {
                return(ActivityIdHeader.ExtractActivityId(message));
            }

            ServiceModelActivity activity = ExtractActivity(message);

            return(activity == null ? Guid.Empty : activity.Id);
        }
示例#19
0
        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);
        }
示例#20
0
        internal static ServiceModelActivity ExtractAndRemoveActivity(Message message)
        {
            ServiceModelActivity retval = TraceUtility.ExtractActivity(message);

            if (retval != null)
            {
                // If the property is just removed, the item is disposed and we don't want the thing
                // to be disposed of.
                message.Properties[TraceUtility.ActivityIdKey] = false;
            }
            return(retval);
        }
示例#21
0
        internal static void TransferFromTransport(Message message)
        {
            if (message != null && DiagnosticUtility.ShouldUseActivity)
            {
                Guid guid = Guid.Empty;

                // Only look if we are allowing user propagation
                if (TraceUtility.ShouldPropagateActivity)
                {
                    guid = ActivityIdHeader.ExtractActivityId(message);
                }

                if (guid == Guid.Empty)
                {
                    guid = Guid.NewGuid();
                }

                ServiceModelActivity activity = null;
                bool emitStart = true;
                if (ServiceModelActivity.Current != null)
                {
                    if ((ServiceModelActivity.Current.Id == guid) ||
                        (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction))
                    {
                        activity  = ServiceModelActivity.Current;
                        emitStart = false;
                    }
                    else if (ServiceModelActivity.Current.PreviousActivity != null &&
                             ServiceModelActivity.Current.PreviousActivity.Id == guid)
                    {
                        activity  = ServiceModelActivity.Current.PreviousActivity;
                        emitStart = false;
                    }
                }

                if (activity == null)
                {
                    activity = ServiceModelActivity.CreateActivity(guid);
                }
                if (DiagnosticUtility.ShouldUseActivity)
                {
                    if (emitStart)
                    {
                        if (null != FxTrace.Trace)
                        {
                            FxTrace.Trace.TraceTransfer(guid);
                        }
                        ServiceModelActivity.Start(activity, SR.Format(SR.ActivityProcessAction, message.Headers.Action), ActivityType.ProcessAction);
                    }
                }
                message.Properties[TraceUtility.ActivityIdKey] = activity;
            }
        }
示例#22
0
        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);
        }
示例#23
0
        internal static ServiceModelActivity CreateActivity(Guid activityId, bool autoStop)
        {
            if (!DiagnosticUtility.ShouldUseActivity)
            {
                return(null);
            }
            ServiceModelActivity activity = CreateActivity(activityId);

            if (activity != null)
            {
                activity.autoStop = autoStop;
            }
            return(activity);
        }
示例#24
0
        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);
        }
示例#25
0
        internal static ServiceModelActivity CreateAsyncActivity()
        {
            if (!DiagnosticUtility.ShouldUseActivity)
            {
                return(null);
            }
            ServiceModelActivity activity = ServiceModelActivity.CreateActivity(true);

            if (activity != null)
            {
                activity._isAsync = true;
            }
            return(activity);
        }
示例#26
0
        internal static ServiceModelActivity CreateBoundedActivity(Guid activityId)
        {
            if (!DiagnosticUtility.ShouldUseActivity)
            {
                return(null);
            }
            ServiceModelActivity activity = CreateActivity(activityId, true);

            if (activity != null)
            {
                activity.activity = (TransferActivity)BoundOperation(activity, true);
            }
            return(activity);
        }
示例#27
0
        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);
        }
 public TracingConnection(IConnection connection, bool inheritCurrentActivity)
     : base(connection)
 {
     this.activity = inheritCurrentActivity ?
         ServiceModelActivity.CreateActivity(DiagnosticTraceBase.ActivityId, false) :
         ServiceModelActivity.CreateActivity();
     Fx.Assert(this.activity != null, "");
     if (DiagnosticUtility.ShouldUseActivity && !inheritCurrentActivity)
     {
         if (null != FxTrace.Trace)
         {
             FxTrace.Trace.TraceTransfer(this.activity.Id);
         }
     }
 }
 internal ProxyRpc(ServiceChannel channel, ProxyOperationRuntime operation, string action, object[] inputs, TimeSpan timeout)
 {
     this.Action = action;
     this.Activity = null;
     this.Channel = channel;
     this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount);
     this.InputParameters = inputs;
     this.Operation = operation;
     this.OutputParameters = null;
     this.Request = null;
     this.Reply = null;
     this.ActivityId = Guid.Empty;
     this.ReturnValue = null;
     this.MessageVersion = channel.MessageVersion;
     this.TimeoutHelper = new System.Runtime.TimeoutHelper(timeout);
 }
示例#30
0
 protected TraceAsyncResult(AsyncCallback callback, object state) : base(callback, state)
 {
     if (TraceUtility.MessageFlowTracingOnly)
     {
         this.CallbackActivity = ServiceModelActivity.CreateLightWeightAsyncActivity(Trace.CorrelationManager.ActivityId);
         base.VirtualCallback  = waitResultCallback;
     }
     else if (DiagnosticUtility.ShouldUseActivity)
     {
         this.CallbackActivity = ServiceModelActivity.Current;
         if (this.CallbackActivity != null)
         {
             base.VirtualCallback = waitResultCallback;
         }
     }
 }
示例#31
0
 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);
         }
     }
 }
示例#32
0
        internal static ServiceModelActivity ExtractActivity(Message message)
        {
            ServiceModelActivity retval = null;

            if ((DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivityGlobal) &&
                (message != null) &&
                (message.State != MessageState.Closed))
            {
                object property;

                if (message.Properties.TryGetValue(TraceUtility.ActivityIdKey, out property))
                {
                    retval = property as ServiceModelActivity;
                }
            }
            return(retval);
        }
示例#33
0
        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);
                }
            }
        }
示例#34
0
        internal static ServiceModelActivity CreateActivity(Guid activityId)
        {
            if (!DiagnosticUtility.ShouldUseActivity)
            {
                return(null);
            }
            ServiceModelActivity activity = null;

            if (activityId != Guid.Empty)
            {
                activity = new ServiceModelActivity(activityId);
            }
            if (activity != null)
            {
                Current = activity;
            }
            return(activity);
        }
        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);
                    }
                }
            }
        }
 private static Activity BoundOperationCore(ServiceModelActivity activity, bool addTransfer)
 {
     if (!DiagnosticUtility.ShouldUseActivity)
     {
         return null;
     }
     TransferActivity activity2 = null;
     if (activity != null)
     {
         activity2 = TransferActivity.CreateActivity(activity.activityId, addTransfer);
         if (activity2 != null)
         {
             activity2.SetPreviousServiceModelActivity(Current);
         }
         Current = activity;
     }
     return activity2;
 }
示例#37
0
 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);
 }
示例#38
0
        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);
        }
示例#39
0
        private 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 TracingConnectionListener(IConnectionListener listener, string traceStartInfo, bool newActivity)
 {
     this.listener = listener;
     if (newActivity)
     {
         this.activity = ServiceModelActivity.CreateActivity();
         if (DiagnosticUtility.ShouldUseActivity)
         {
             if (FxTrace.Trace != null)
             {
                 FxTrace.Trace.TraceTransfer(this.activity.Id);
             }
             ServiceModelActivity.Start(this.activity, System.ServiceModel.SR.GetString("ActivityListenAt", new object[] { traceStartInfo }), ActivityType.ListenAt);
         }
     }
     else
     {
         this.activity = ServiceModelActivity.CreateActivity(DiagnosticTrace.ActivityId, false);
         if (this.activity != null)
         {
             this.activity.Name = traceStartInfo;
         }
     }
 }
 internal void Open()
 {
     this.activity = MsmqDiagnostics.StartListenAtActivity(this);
     using (MsmqDiagnostics.BoundOpenOperation(this))
     {
         this.queue.EnsureOpen();
         this.poisonHandler.Open();
     }
 }
 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 void GetActivityInfo(ref ServiceModelActivity activity, ref Activity boundOperation)
 {
     if (TraceUtility.MessageFlowTracingOnly)
     {
         if (null != OperationContext.Current)
         {
             Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
             if (activityId != Guid.Empty)
             {
                 DiagnosticTraceBase.ActivityId = activityId;
             }
         }
     }
     else if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
     {
         object activityInfo = TraceUtility.ExtractAsyncOperationContextActivity();
         if (activityInfo != null)
         {
             if (DiagnosticUtility.ShouldUseActivity)
             {
                 activity = activityInfo as ServiceModelActivity;
                 boundOperation = ServiceModelActivity.BoundOperation(activity, true);
             }
             else if (TraceUtility.ShouldPropagateActivity)
             {
                 if (activityInfo is Guid)
                 {
                     Guid activityId = (Guid)activityInfo;
                     boundOperation = Activity.CreateActivity(activityId);
                 }
             }
         }
     }
 }
 protected void StartReceiveBytesActivity(ServiceModelActivity activity, Uri requestUri)
 {
     ServiceModelActivity.Start(activity, System.ServiceModel.SR.GetString("ActivityReceiveBytes", new object[] { requestUri.ToString() }), ActivityType.ReceiveBytes);
 }
示例#45
0
 internal static void SetActivity(Message message, ServiceModelActivity activity)
 {
     if (DiagnosticUtility.ShouldUseActivity && message != null && message.State != MessageState.Closed)
     {
         message.Properties[TraceUtility.ActivityIdKey] = activity;
     }
 }
 public SecurityProtocolCorrelationState(SecurityToken token)
 {
     this.token = token;
     this.activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.Current : null;
 }
 static internal Activity BoundOperation(ServiceModelActivity activity, bool addTransfer)
 {
     return activity == null ? null : ServiceModelActivity.BoundOperationCore(activity, addTransfer);
 }
示例#48
0
        internal MessageRpc(RequestContext requestContext, Message request, DispatchOperationRuntime operation,
            ServiceChannel channel, ServiceHostBase host, ChannelHandler channelHandler, bool cleanThread,
            OperationContext operationContext, InstanceContext instanceContext, EventTraceActivity eventTraceActivity)
        {
            Fx.Assert((operationContext != null), "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), operationContext == null");
            Fx.Assert(channelHandler != null, "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), channelHandler == null");

            this.Activity = null;
            this.EventTraceActivity = eventTraceActivity;            
            this.AsyncResult = null;
            this.CanSendReply = true;
            this.Channel = channel;
            this.channelHandler = channelHandler;
            this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount);
            this.CorrelationCallback = null;
            this.DidDeserializeRequestBody = false;
            this.TransactionMessageProperty = null;
            this.TransactedBatchContext = null;
            this.Error = null;
            this.ErrorProcessor = null;
            this.FaultInfo = new ErrorHandlerFaultInfo(request.Version.Addressing.DefaultFaultAction);
            this.HasSecurityContext = false;
            this.Host = host;
            this.Instance = null;
            this.MessageRpcOwnsInstanceContextThrottle = false;
            this.NextProcessor = null;
            this.NotUnderstoodHeaders = null;
            this.Operation = operation;
            this.OperationContext = operationContext;
            this.paused = false;
            this.ParametersDisposed = false;
            this.ReceiveContext = null;
            this.Request = request;
            this.RequestContext = requestContext;
            this.RequestContextThrewOnReply = false;
            this.SuccessfullySendReply = false;
            this.RequestVersion = request.Version;
            this.Reply = null;
            this.ReplyTimeoutHelper = new TimeoutHelper();
            this.SecurityContext = null;
            this.InstanceContext = instanceContext;
            this.SuccessfullyBoundInstance = false;
            this.SuccessfullyIncrementedActivity = false;
            this.SuccessfullyLockedInstance = false;
            this.switchedThreads = !cleanThread;
            this.transaction = null;
            this.InputParameters = null;
            this.OutputParameters = null;
            this.ReturnParameter = null;
            this.isInstanceContextSingleton = InstanceContextProviderBase.IsProviderSingleton(this.Channel.DispatchRuntime.InstanceContextProvider);
            this.invokeContinueGate = null;

            if (!operation.IsOneWay && !operation.Parent.ManualAddressing)
            {
                this.RequestID = request.Headers.MessageId;
                this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo(request);
            }
            else
            {
                this.RequestID = null;
                this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo();
            }

            this.HostingProperty = AspNetEnvironment.Current.GetHostingProperty(request, true);

            if (DiagnosticUtility.ShouldUseActivity)
            {
                this.Activity = TraceUtility.ExtractActivity(this.Request);
            }

            if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
            {
                this.ResponseActivityId = ActivityIdHeader.ExtractActivityId(this.Request);
            }
            else
            {
                this.ResponseActivityId = Guid.Empty;
            }

            this.InvokeNotification = new MessageRpcInvokeNotification(this.Activity, this.channelHandler);

            if (this.EventTraceActivity == null && FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
            {
                if (this.Request != null)
                {
                    this.EventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.Request, true);
                }
            }
        }
 public TracingConnection(IConnection connection, ServiceModelActivity activity)
     : base(connection)
 {
     this.activity = activity;
 }
 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;
 }
 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);
         }
     }
 }
 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);
     }
 }
 static internal void Stop(ServiceModelActivity activity)
 {
     if (activity != null)
     {
         activity.Stop();
     }
 }
 internal void SetPreviousServiceModelActivity(ServiceModelActivity previous)
 {
     this.previousActivity = previous;
     this.changeCurrentServiceModelActivity = true;
 }
示例#55
0
 public MessageRpcInvokeNotification(ServiceModelActivity activity, ChannelHandler handler)
 {
     this.activity = activity;
     this.handler = handler;
 }
 internal static void Start(ServiceModelActivity activity, string activityName, System.ServiceModel.Diagnostics.ActivityType activityType)
 {
     if ((activity != null) && (activity.LastState == ActivityState.Unknown))
     {
         activity.LastState = ActivityState.Start;
         activity.name = activityName;
         activity.activityType = activityType;
         activity.TraceMilestone(TraceEventType.Start);
     }
 }
 internal TracingConnectionState(WaitCallback callback, ServiceModelActivity activity, object state)
 {
     this.activity = activity;
     this.callback = callback;
     this.state = state;
 }
 internal TracingConnectionListener(IConnectionListener listener)
 {
     this.listener = listener;
     this.activity = ServiceModelActivity.CreateActivity(DiagnosticTrace.ActivityId, false);
 }
 internal TracingConnectionInitiator(IConnectionInitiator connectionInitiator, bool isClient)
 {
     this.connectionInitiator = connectionInitiator;
     this.activity = ServiceModelActivity.CreateActivity(DiagnosticTraceBase.ActivityId);
     this.isClient = isClient;
 }
 ServiceModelActivity(Guid activityId)
 {
     this.activityId = activityId;
     this.previousActivity = ServiceModelActivity.Current;
 }