internal TrackingRecord Match(TrackingRecord record, bool shouldClone) { TrackingQuery resultQuery = null; if (record is WorkflowInstanceRecord) { resultQuery = Match((WorkflowInstanceRecord)record); } else if (record is ActivityStateRecord) { resultQuery = Match((ActivityStateRecord)record); } else if (record is BookmarkResumptionRecord) { resultQuery = Match((BookmarkResumptionRecord)record); } else if (record is CustomTrackingRecord) { resultQuery = Match((CustomTrackingRecord)record); } else if (record is ActivityScheduledRecord) { resultQuery = Match((ActivityScheduledRecord)record); } else if (record is CancelRequestedRecord) { resultQuery = Match((CancelRequestedRecord)record); } else if (record is FaultPropagationRecord) { resultQuery = Match((FaultPropagationRecord)record); } return(resultQuery == null ? null : PrepareRecord(record, resultQuery, shouldClone)); }
protected override void Track(TrackingRecord record, TimeSpan timeout) { try { var connection = new WCFDataSourceOf_NonValueEventClient(); if (record is System.Activities.Tracking.WorkflowInstanceRecord) { var r = record as WorkflowInstanceRecord; connection.PushEvent(new NonValueEvent { Name = r.ActivityDefinitionId, Time = r.EventTime, TrackEventType = (int) TrackEventType.InstanseStart }); } else if (record is System.Activities.Tracking.ActivityStateRecord) { var r = record as ActivityStateRecord; connection.PushEvent(new NonValueEvent { Name = r.Activity.Name, Time = r.EventTime, TrackEventType = (int) TrackEventType.ActivityStart }); } } catch(Exception ex) { Debugger.Break(); Console.WriteLine(ex.Message); } }
public TrackAsyncResult(TrackingParticipant participant, TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.participant = participant; this.record = record; this.timeout = timeout; ActionItem.Schedule(asyncExecuteTrack, this); }
protected internal override void Track(TrackingRecord record, TimeSpan timeout) { if (this.diagnosticTrace.IsEtwProviderEnabled) { if (record is ActivityStateRecord) { this.TrackActivityRecord((ActivityStateRecord)record); } else if (record is WorkflowInstanceRecord) { this.TrackWorkflowRecord((WorkflowInstanceRecord)record); } else if (record is BookmarkResumptionRecord) { this.TrackBookmarkRecord((BookmarkResumptionRecord)record); } else if (record is ActivityScheduledRecord) { this.TrackActivityScheduledRecord((ActivityScheduledRecord)record); } else if (record is CancelRequestedRecord) { this.TrackCancelRequestedRecord((CancelRequestedRecord)record); } else if (record is FaultPropagationRecord) { this.TrackFaultPropagationRecord((FaultPropagationRecord)record); } else { this.TrackCustomRecord((CustomTrackingRecord)record); } } }
//On Tracing Record Received call the TrackingRecordReceived with the record received information from the TrackingParticipant. //We also do not worry about Expressions' tracking data protected void OnTrackingRecordReceived(TrackingRecord record, TimeSpan timeout) { System.Diagnostics.Debug.WriteLine( String.Format("Tracking Record Received: {0} with timeout: {1} seconds.", record, timeout.TotalSeconds) ); if (TrackingRecordReceived != null) { ActivityStateRecord activityStateRecord = record as ActivityStateRecord; if((activityStateRecord != null) && (!activityStateRecord.Activity.TypeName.Contains("System.Activities.Expressions"))) { if (ActivityIdToWorkflowElementMap.ContainsKey(activityStateRecord.Activity.Id)) { TrackingRecordReceived(this, new TrackingEventArgs( record, timeout, ActivityIdToWorkflowElementMap[activityStateRecord.Activity.Id] ) ); } } else { TrackingRecordReceived(this, new TrackingEventArgs(record, timeout,null)); } } }
public TrackingMessage(TrackingRecord trackingRecord) { RecordType = trackingRecord.GetType().Name; InstanceId = trackingRecord.InstanceId.ToString(); RecordNumber = trackingRecord.RecordNumber; EventTime = trackingRecord.EventTime; Content = trackingRecord.ToString().Replace("<null>", "null"); if (trackingRecord is WorkflowInstanceRecord) { ActivityDefinitionId = ((WorkflowInstanceRecord)trackingRecord).ActivityDefinitionId; State = ((WorkflowInstanceRecord)trackingRecord).State; } if (trackingRecord is ActivityScheduledRecord) { Activity = ((ActivityScheduledRecord)trackingRecord).Activity.Name; ChildActivity = ((ActivityScheduledRecord)trackingRecord).Child.Name; } if (trackingRecord is ActivityStateRecord) { Activity = ((ActivityStateRecord)trackingRecord).Activity.Name; State = ((ActivityStateRecord)trackingRecord).State; Variables = ((ActivityStateRecord)trackingRecord).Variables.ToDictionary(kvp => kvp.Key, kvp => kvp.Value == null ? null : kvp.Value.ToString()); Arguments = ((ActivityStateRecord)trackingRecord).Arguments.ToDictionary(kvp => kvp.Key, kvp => kvp.Value == null ? null : kvp.Value.ToString()); } if (trackingRecord is CustomTrackingRecord) { Activity = ((CustomTrackingRecord)trackingRecord).Activity.Name; Name = ((CustomTrackingRecord)trackingRecord).Name; Data = string.Join(", ", ((CustomTrackingRecord)trackingRecord).Data.Select(kvp => string.Format("{0} = {1}", kvp.Key, kvp.Value))); } if (trackingRecord is WorkflowInstanceUnhandledExceptionRecord) { Activity = ((WorkflowInstanceUnhandledExceptionRecord)trackingRecord).FaultSource.Name; Data = ((WorkflowInstanceUnhandledExceptionRecord)trackingRecord).UnhandledException.ToString(); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { StringBuilder trackingContents = new StringBuilder(); trackingContents.AppendFormat(CultureInfo.InvariantCulture, "{0}: Level: {1}, RecordNumber: {2}", record.GetType().Name, record.Level, record.RecordNumber); if (record is WorkflowInstanceRecord) { trackingContents.AppendFormat(CultureInfo.InvariantCulture, " Workflow InstanceID: {0} Workflow instance state: {1}\n", record.InstanceId, ((WorkflowInstanceRecord)record).State); } else if (record is ActivityStateRecord) { ActivityStateRecord activityTrackingRecord = (ActivityStateRecord)record; IDictionary<String, object> variables = activityTrackingRecord.Variables; StringBuilder vars = new StringBuilder(); if (variables.Count > 0) { vars.AppendLine("\n\tVariables:"); foreach (KeyValuePair<string, object> variable in variables) { vars.AppendLine(String.Format( "\t\tName: {0} Value: {1}", variable.Key, variable.Value)); } } trackingContents.AppendFormat(CultureInfo.InvariantCulture, " :Activity DisplayName: {0} :ActivityInstanceState: {1} {2}\n", activityTrackingRecord.Activity.Name, activityTrackingRecord.State, ((variables.Count > 0) ? vars.ToString() : String.Empty)); } else if (record is ActivityScheduledRecord) { trackingContents.AppendFormat(CultureInfo.InvariantCulture, " :ChildActivity DisplayName: {0}\n", ((ActivityScheduledRecord)record).Child.Name); } else if (record is CustomTrackingRecord) { CustomTrackingRecord userTrackingRecord = (CustomTrackingRecord)record; if (userTrackingRecord.Data.Count > 0) { trackingContents.AppendFormat(CultureInfo.InvariantCulture, "\n\tUser Data:\n"); foreach (string data in userTrackingRecord.Data.Keys) { trackingContents.AppendFormat(CultureInfo.InvariantCulture, " \t\t {0} : {1}\n", data, userTrackingRecord.Data[data]); } } } this.writer.WriteLine(trackingContents); }
/// <summary> /// Dispatched the tracking record /// </summary> /// <param name="record"></param> /// <param name="timeout"></param> protected override void Track(TrackingRecord record, TimeSpan timeout) { IConnection connection = Connection.GetConnection<TrackingViewerConnection>(); if(connection != null) { connection.Broadcast(new TrackingMessage(record)).Wait(); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { fileName = @"D:\" + record.InstanceId + ".tracking"; using (StreamWriter sw = File.AppendText(fileName)) { sw.WriteLine("----------Tracking Started-----------"); sw.WriteLine(record.ToString()); sw.WriteLine("----------Tracking End---------------"); } }
public void AddRecord(TrackingRecord record) { if (this.pendingTrackingRecords == null) { this.pendingTrackingRecords = new List <TrackingRecord>(); } record.RecordNumber = this.GetNextRecordNumber(); this.pendingTrackingRecords.Add(record); }
public void AddRecord(TrackingRecord record) { if (this.pendingTrackingRecords == null) { this.pendingTrackingRecords = new List<TrackingRecord>(); } record.RecordNumber = this.GetNextRecordNumber(); this.pendingTrackingRecords.Add(record); }
/// <summary> /// Appends the current TrackingRecord data to the Workflow Execution Log /// </summary> /// <param name="trackRecord">Tracking Record Data</param> /// <param name="timeStamp">Timestamp</param> protected override void Track(TrackingRecord trackRecord, TimeSpan timeStamp) { ActivityStateRecord recordEntry = trackRecord as ActivityStateRecord; if (recordEntry != null) { TrackData += String.Format("[{0}] [{1}] [{2}]" + Environment.NewLine, recordEntry.EventTime.ToString(), recordEntry.Activity.Name, recordEntry.State); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { LoggingEntry entry = null; var timeSpanValue = ExecutionTime?.GetTimeInfo(record); var commoninfo = $"{record.RecordNumber:00000} {timeSpanValue}"; if (IsSet(StateChangeRecords.ActivityState) && record is ActivityStateRecord) { var staterecord = (ActivityStateRecord) record; entry = new LoggingEntry($"{commoninfo} {record.GetType().Name} {staterecord.Activity.Name} ({staterecord.Activity.TypeName}) {staterecord.State}"); // add each variable/value to foreach (var valuePair in staterecord.Variables) { entry.AdditionalInformations.Add(new PropertyEntry() {Name = valuePair.Key, Value = valuePair.Value}); } } else if (IsSet(StateChangeRecords.ActivityScheduled) && record is ActivityScheduledRecord) { var scheduledrecord = (ActivityScheduledRecord) record; _writerAdapter.WriteLine($"{commoninfo} {scheduledrecord?.Activity?.Name} ({scheduledrecord?.Activity?.TypeName}) Child: {scheduledrecord.Child.Name}"); } else if (IsSet(StateChangeRecords.WorkflowInstance) && record is WorkflowInstanceRecord) { var instancerecord = (WorkflowInstanceRecord) record; _writerAdapter.WriteLine($"{commoninfo} State of workflow changed: {instancerecord.State}"); } else if (IsSet(StateChangeRecords.CancelRequested) && record is CancelRequestedRecord) { var cancelrecord = (CancelRequestedRecord) record; _writerAdapter.WriteLine($"{commoninfo} {record.GetType().Name} {cancelrecord.Activity?.Name}"); } else if (IsSet(StateChangeRecords.FaultPropagation) && record is FaultPropagationRecord) { var faultrecord = (FaultPropagationRecord) record; _writerAdapter.WriteLine($"{commoninfo} Fault {faultrecord?.Fault.Message}"); } if (record.Annotations.Any()) { Debug.WriteLine($"Anmerkungen bei {record.RecordNumber}"); } if (entry != null) { entry.Annotations.AddRange(record.Annotations.Values.ToList()); _writerAdapter.WriteEntry(entry); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { if (Tracking != null) Tracking.Update(record); var instanceRecord = record as WorkflowInstanceRecord; if (instanceRecord != null) { Status = instanceRecord.State; } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord; if (workflowInstanceRecord != null) { string message = string.Format("Sequence: {0} Instance id: {1}, state = {2}", workflowInstanceRecord.RecordNumber, workflowInstanceRecord.InstanceId, workflowInstanceRecord.State); Console.WriteLine(message); } }
protected TrackingRecord(TrackingRecord record) { this.InstanceId = record.InstanceId; this.RecordNumber = record.RecordNumber; this.EventTime = record.EventTime; this.Level = record.Level; if (record.HasAnnotations) { this.annotations = new ReadOnlyDictionary <string, string>(record.annotations); } }
protected TrackingRecord(TrackingRecord record) { this.InstanceId = record.InstanceId; this.RecordNumber = record.RecordNumber; this.EventTime = record.EventTime; this.Level = record.Level; if (record.HasAnnotations) { this.annotations = new ReadOnlyDictionary<string, string>(record.annotations); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { if (record != null) { ActivityStateRecord activityState = (ActivityStateRecord)record; if (ActivityStateTracked != null) ActivityStateTracked(this, new ActivityStateTrackedEventArgs(activityState)); } }
protected override void Track(TrackingRecord trackingRecord, TimeSpan timeout) { WorkflowInstanceRecord record = trackingRecord as WorkflowInstanceRecord; if (record != null) { if (record.State == WorkflowInstanceStates.Aborted || record.State == WorkflowInstanceStates.Completed || record.State == WorkflowInstanceStates.UnhandledException) { syncEvent.Set(); } } }
protected override void Track(TrackingRecord trackingRecord, TimeSpan timeout) { WorkflowInstanceRecord record = trackingRecord as WorkflowInstanceRecord; if (record != null) { if (record.State == WorkflowInstanceStates.Aborted || record.State == WorkflowInstanceStates.Completed || record.State == WorkflowInstanceStates.UnhandledException) { Console.WriteLine("EventTrackingParticipant: Workflow is {0}", record.State); syncEvent.Set(); } } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { // get the tracking path string fileName = IOHelper.GetTrackingFilePath(record.InstanceId); // create a writer and open the file using (StreamWriter tw = File.AppendText(fileName)) { // write a line of text to the file tw.WriteLine(record.ToString()); } }
/// <summary> /// Retrieve each type of tracking record and perform the corresponding functionality. /// </summary> /// <param name="record">Represents the tracking record.</param> /// <param name="timeout">Time out for the tracking to be completed.</param> protected override void Track(TrackingRecord record, TimeSpan timeout) { Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "{0} Emitted trackRecord: {1} Level: {2}, RecordNumber: {3}", participantName, record.GetType().FullName, record.Level, record.RecordNumber)); WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord; if (workflowInstanceRecord != null) { if (_structuredTracer.IsEnabled) { if (string.Equals(WorkflowInstanceStates.Persisted, workflowInstanceRecord.State, StringComparison.OrdinalIgnoreCase)) { _structuredTracer.WorkflowPersisted(workflowInstanceRecord.InstanceId); } else if (string.Equals(WorkflowInstanceStates.UnhandledException, workflowInstanceRecord.State, StringComparison.OrdinalIgnoreCase)) { WorkflowInstanceUnhandledExceptionRecord unhandledRecord = workflowInstanceRecord as WorkflowInstanceUnhandledExceptionRecord; if (unhandledRecord != null) { _structuredTracer.WorkflowActivityExecutionFailed(unhandledRecord.InstanceId, unhandledRecord.FaultSource != null ? unhandledRecord.FaultSource.Name : unhandledRecord.ActivityDefinitionId, System.Management.Automation.Tracing.Tracer.GetExceptionString(unhandledRecord.UnhandledException)); } } } this.ProcessWorkflowInstanceRecord(workflowInstanceRecord); } ActivityStateRecord activityStateRecord = record as ActivityStateRecord; if (activityStateRecord != null) { if (_structuredTracer.IsEnabled) { ActivityInstanceState activityState = ActivityInstanceState.Executing; if (!string.IsNullOrEmpty(activityStateRecord.State) && Enum.TryParse<ActivityInstanceState>(activityStateRecord.State, out activityState)) { if (activityState == ActivityInstanceState.Executing) { _structuredTracer.ActivityExecutionQueued(activityStateRecord.InstanceId, activityStateRecord.Activity.Name); } } } this.ProcessActivityStateRecord(activityStateRecord); } CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord; if ((customTrackingRecord != null) && (customTrackingRecord.Data.Count > 0)) { this.ProcessCustomTrackingRecord(customTrackingRecord); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { // Log header information AddEvent(String.Format("Type: {0} Level: {1}, RecordNumber: {2}", record.GetType().Name, record.Level, record.RecordNumber)); // If this is a instance record WorkflowInstanceRecord instance = record as WorkflowInstanceRecord; if (instance != null) { AddEvent(String.Format(" InstanceID: {0} State: {1}",instance.InstanceId, instance.State)); } // If this is a bookmark record BookmarkResumptionRecord bookmark = record as BookmarkResumptionRecord; if (bookmark != null) { AddEvent(String.Format(" Bookmark {0} resumed",bookmark.BookmarkName)); } // If this is an activity record ActivityStateRecord activity = record as ActivityStateRecord; if (activity != null) { IDictionary<String, object> variables = activity.Variables; StringBuilder s = new StringBuilder(); if (variables.Count > 0) { s.AppendLine(" Variables:"); foreach (KeyValuePair<string, object> v in variables) { s.AppendLine(String.Format(" {0} Value: [{1}]",v.Key, v.Value)); } } AddEvent(String.Format(" Activity: {0} State: {1} {2}",activity.Activity.Name, activity.State, s.ToString())); } // If this is a user record CustomTrackingRecord user = record as CustomTrackingRecord; if ((user != null) && (user.Data.Count > 0)) { AddEvent(String.Format(" User Data: {0}", user.Name)); foreach (string data in user.Data.Keys) { AddEvent(String.Format(" {0} : {1}", data, user.Data[data])); } } }
public void FlushPendingRecords(TimeSpan timeout) { try { if (this.HasPendingRecords) { TimeoutHelper helper = new TimeoutHelper(timeout); for (int i = 0; i < this.trackingParticipants.Count; i++) { TrackingParticipant participant = this.trackingParticipants[i]; RuntimeTrackingProfile runtimeProfile = GetRuntimeTrackingProfile(participant); // HasPendingRecords can be true for the sole purpose of populating our initial profiles, so check again here if (this.pendingTrackingRecords != null) { for (int j = 0; j < this.pendingTrackingRecords.Count; j++) { TrackingRecord currentRecord = this.pendingTrackingRecords[j]; Fx.Assert(currentRecord != null, "We should never come across a null context."); TrackingRecord preparedRecord = null; bool shouldClone = this.trackingParticipants.Count > 1; if (runtimeProfile == null) { preparedRecord = shouldClone ? currentRecord.Clone() : currentRecord; } else { preparedRecord = runtimeProfile.Match(currentRecord, shouldClone); } if (preparedRecord != null) { participant.Track(preparedRecord, helper.RemainingTime()); if (TD.TrackingRecordRaisedIsEnabled()) { TD.TrackingRecordRaised(preparedRecord.ToString(), participant.GetType().ToString()); } } } } } } } finally { // Note that if we fail to track yet the workflow manages to recover // we will attempt to track those records again. ClearPendingRecords(); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { Console.Write(String.Format(CultureInfo.InvariantCulture, "{0} emitted trackRecord: {1} Level: {2}, RecordNumber: {3}", participantName, record.GetType().FullName, record.Level, record.RecordNumber)); WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord; if (workflowInstanceRecord != null) { Console.WriteLine(String.Format(CultureInfo.InvariantCulture, " Workflow InstanceID: {0} Workflow instance state: {1}", record.InstanceId, workflowInstanceRecord.State)); } ActivityStateRecord activityStateRecord = record as ActivityStateRecord; if (activityStateRecord != null) { IDictionary<String, object> variables = activityStateRecord.Variables; StringBuilder vars = new StringBuilder(); if (variables.Count > 0) { vars.AppendLine("\n\tVariables:"); foreach (KeyValuePair<string, object> variable in variables) { vars.AppendLine(String.Format( "\t\tName: {0} Value: {1}", variable.Key, variable.Value)); } } Console.WriteLine(String.Format(CultureInfo.InvariantCulture, " :Activity DisplayName: {0} :ActivityInstanceState: {1} {2}", activityStateRecord.Activity.Name, activityStateRecord.State, ((variables.Count > 0) ? vars.ToString() : String.Empty))); } CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord; if ((customTrackingRecord != null) && (customTrackingRecord.Data.Count > 0)) { Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "\n\tUser Data:")); foreach (string data in customTrackingRecord.Data.Keys) { Console.WriteLine(String.Format(CultureInfo.InvariantCulture, " \t\t {0} : {1}", data, customTrackingRecord.Data[data])); } } Console.WriteLine(); }
private static TrackingRecord PrepareRecord(TrackingRecord record, TrackingQuery query, bool shouldClone) { TrackingRecord record2 = shouldClone ? record.Clone() : record; if (query.HasAnnotations) { record2.Annotations = new ReadOnlyDictionary <string, string>(query.QueryAnnotations, false); } if (query is ActivityStateQuery) { ExtractArguments((ActivityStateRecord)record2, (ActivityStateQuery)query); ExtractVariables((ActivityStateRecord)record2, (ActivityStateQuery)query); } return(record2); }
bool PostTrackingRecord(TrackingParticipant participant, RuntimeTrackingProfile runtimeProfile) { TrackingRecord originalRecord = this.provider.pendingTrackingRecords[this.currentRecord]; this.currentRecord++; bool isSuccessful = false; try { TrackingRecord preparedRecord = null; bool shouldClone = this.provider.trackingParticipants.Count > 1; if (runtimeProfile == null) { preparedRecord = shouldClone ? originalRecord.Clone() : originalRecord; } else { preparedRecord = runtimeProfile.Match(originalRecord, shouldClone); } if (preparedRecord != null) { IAsyncResult result = participant.BeginTrack(preparedRecord, this.timeoutHelper.RemainingTime(), PrepareAsyncCompletion(trackingCompleteCallback), this); if (TD.TrackingRecordRaisedIsEnabled()) { TD.TrackingRecordRaised(preparedRecord.ToString(), participant.GetType().ToString()); } if (result.CompletedSynchronously) { participant.EndTrack(result); } else { isSuccessful = true; return(false); } } isSuccessful = true; } finally { if (!isSuccessful) { this.provider.ClearPendingRecords(); } } return(true); }
public override string GetTimeInfo(TrackingRecord record) { TimeSpan timeSpan; if (record.RecordNumber == 0) { _startTime = record.EventTime.ToLocalTime(); timeSpan = new TimeSpan(0, 0, 0, 0, 0); } else { timeSpan = record.EventTime.ToLocalTime() - _startTime; } return timeSpan.ToString("mm\\:ss\\.fff"); }
static TrackingRecord PrepareRecord(TrackingRecord record, TrackingQuery query, bool shouldClone) { TrackingRecord preparedRecord = shouldClone ? record.Clone() : record; if (query.HasAnnotations) { preparedRecord.Annotations = new ReadOnlyDictionaryInternal <string, string>(query.QueryAnnotations); } if (query is ActivityStateQuery) { ExtractArguments((ActivityStateRecord)preparedRecord, (ActivityStateQuery)query); ExtractVariables((ActivityStateRecord)preparedRecord, (ActivityStateQuery)query); } return(preparedRecord); }
protected override void Track(TrackingRecord record, TimeSpan timeout) { // get the custom record CustomTrackingRecord customRecord = (CustomTrackingRecord)record; string hiringRequestId = customRecord.Data["HiringRequestId"].ToString(); // create the request history record historyRecord = new RequestHistoryRecord(); historyRecord.RequestId = hiringRequestId; historyRecord.RecordNumber = record.RecordNumber; historyRecord.Action = GetStringFromTrackingRecord("Action", customRecord.Data); historyRecord.SourceState = GetStringFromTrackingRecord("State", customRecord.Data); historyRecord.Comment = GetStringFromTrackingRecord("Comment", customRecord.Data); historyRecord.EmployeeId = GetStringFromTrackingRecord("EmployeeId", customRecord.Data); historyRecord.EmployeeName = GetStringFromTrackingRecord("EmployeeName", customRecord.Data); historyRecord.Date = GetDateFromTrackingRecord(customRecord.Data); }
protected void OnTrackingRecordReceived(TrackingRecord record, TimeSpan timeout) { ActivityStateRecord activityStateRecord = record as ActivityStateRecord; if(TrackingRecordReceived != null) { if(activityStateRecord != null && !activityStateRecord.Activity.TypeName.Contains("System.Activities.Expressions")) { if(ActivityIdToWorkflowElementMap.ContainsKey(activityStateRecord.Activity.Id)) { TrackingRecordReceived(this, new CustomTrackingEventArgs(record, timeout, ActivityIdToWorkflowElementMap[activityStateRecord.Activity.Id])); } } } else { TrackingRecordReceived(this, new CustomTrackingEventArgs(record, timeout, null)); } }
private bool PostTrackingRecord(TrackingParticipant participant, RuntimeTrackingProfile runtimeProfile) { TrackingRecord record = this.provider.pendingTrackingRecords[this.currentRecord]; this.currentRecord++; bool flag = false; try { TrackingRecord record2 = null; bool shouldClone = this.provider.trackingParticipants.Count > 1; if (runtimeProfile == null) { record2 = shouldClone ? record.Clone() : record; } else { record2 = runtimeProfile.Match(record, shouldClone); } if (record2 != null) { IAsyncResult result = participant.BeginTrack(record2, this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(trackingCompleteCallback), this); if (TD.TrackingRecordRaisedIsEnabled()) { TD.TrackingRecordRaised(record2.ToString(), participant.GetType().ToString()); } if (!result.CompletedSynchronously) { flag = true; return(false); } participant.EndTrack(result); } flag = true; } finally { if (!flag) { this.provider.ClearPendingRecords(); } } return(true); }
public void FlushPendingRecords(TimeSpan timeout) { try { if (this.HasPendingRecords) { TimeoutHelper helper = new TimeoutHelper(timeout); for (int i = 0; i < this.trackingParticipants.Count; i++) { TrackingParticipant participant = this.trackingParticipants[i]; RuntimeTrackingProfile runtimeTrackingProfile = this.GetRuntimeTrackingProfile(participant); if (this.pendingTrackingRecords != null) { for (int j = 0; j < this.pendingTrackingRecords.Count; j++) { TrackingRecord record = this.pendingTrackingRecords[j]; TrackingRecord record2 = null; bool shouldClone = this.trackingParticipants.Count > 1; if (runtimeTrackingProfile == null) { record2 = shouldClone ? record.Clone() : record; } else { record2 = runtimeTrackingProfile.Match(record, shouldClone); } if (record2 != null) { participant.Track(record2, helper.RemainingTime()); if (TD.TrackingRecordRaisedIsEnabled()) { TD.TrackingRecordRaised(record2.ToString(), participant.GetType().ToString()); } } } } } } } finally { this.ClearPendingRecords(); } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { ActivityStateRecord asr = record as ActivityStateRecord; if (asr != null) { if (asr.State == ActivityStates.Executing && asr.Activity.TypeName == "System.Activities.Statements.WriteLine") { // Append the WriteLine output to the tracking // file for this instance using (StreamWriter writer = File.AppendText(record.InstanceId.ToString())) { writer.WriteLine(asr.Arguments["Text"]); writer.Close(); } } } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { if (System.Diagnostics.Debugger.IsAttached) { ActivityStateRecord aRecord = record as ActivityStateRecord; if (aRecord != null) { System.Diagnostics.Debug.WriteLine("{0} entered state {1}", aRecord.Activity.Name, aRecord.State); foreach (var item in aRecord.Arguments) { System.Diagnostics.Debug.WriteLine("Argument:{0} has value: {1}", item.Key, item.Value); } foreach (var item in aRecord.Variables) { System.Diagnostics.Debug.WriteLine("Variable:{0} has value: {1}", item.Key, item.Value); } } } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { Type recordType = record.GetType(); Writer.WriteLine("[" + record.RecordNumber + "] ({" + record.EventTime + "}) Instance: " + record.InstanceId); if (record.Annotations.Count > 0) { Writer.WriteLine("Annotations:"); foreach (string key in record.Annotations.Keys) { Writer.WriteLine("\t" + key + "\t" + record.Annotations[key]); } } if (recordType == typeof(WorkflowInstanceUnhandledExceptionRecord)) { WorkflowInstanceUnhandledExceptionRecord crecord = (WorkflowInstanceUnhandledExceptionRecord)record; RecordWriteLine(crecord, "-----------Exception"); RecordWriteLine(crecord, crecord.UnhandledException.ToString()); RecordWriteLine(crecord, "-----------End Exception"); } else if (recordType == typeof(WorkflowInstanceRecord)) { WorkflowInstanceRecord crecord = (WorkflowInstanceRecord)record; RecordWriteLine(crecord, "Workflow State: " + crecord.State); } else if (recordType == typeof(ActivityStateRecord)) { ActivityStateRecord crecord = (ActivityStateRecord)record; RecordWriteLine(crecord, "Activity, " + crecord.Activity.Name + ", entered state: " + crecord.State); if (crecord.Variables.Count > 0) { Writer.WriteLine("Variables:"); foreach (string key in crecord.Variables.Keys) { Writer.WriteLine("\t" + key + "\t" + crecord.Variables[key].ToString()); } } } }
protected override void Track(TrackingRecord record, TimeSpan timeout) { var buildMessage = record as BuildInformationRecord<BuildMessage>; if (buildMessage != null && buildMessage.Value != null) { this.buildMessage.AppendLine(buildMessage.Value.Message); } var buildWarning = record as BuildInformationRecord<BuildWarning>; if (buildWarning != null && buildWarning.Value != null) { this.buildMessage.AppendLine(buildWarning.Value.Message); } var buildError = record as BuildInformationRecord<BuildError>; if (buildError != null && buildError.Value != null) { this.buildMessage.AppendLine(buildError.Value.Message); } }
// The track method is called whenever the workflow runtime emits a tracking record protected override void Track(TrackingRecord record, TimeSpan timeout) { try { using (FileStream fs = new FileStream(Environment.ExpandEnvironmentVariables(Path), FileMode.Append)) { XmlTextWriter writer = new XmlTextWriter(fs, ASCIIEncoding.ASCII) { Formatting = Formatting.Indented }; DataContractSerializer serializer = new DataContractSerializer(record.GetType()); serializer.WriteObject(writer, record); writer.WriteRaw(Environment.NewLine); writer.Flush(); fs.Flush(); } } catch (Exception e) { Trace.WriteLine(String.Format(CultureInfo.InvariantCulture, "Exception in track method {0}", e.Message)); } }
protected internal override void Track(TrackingRecord record, TimeSpan timeout) { throw new NotImplementedException(); }
protected override void Track(TrackingRecord record, TimeSpan timeout) { TrackingMessages.OnNext(new TrackingMessage(record)); }
public TrackingEventArgs(TrackingRecord trackingRecord, TimeSpan timeout, Activity activity) { this.Record = trackingRecord; this.Timeout = timeout; this.Activity = activity; }
protected TrackingRecord(TrackingRecord record) { throw new NotImplementedException(); }
protected internal virtual IAsyncResult BeginTrack(TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) { throw new NotImplementedException(); }
protected internal override IAsyncResult BeginTrack(TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) { this.Track(record, timeout); return(new CompletedAsyncResult(callback, state)); }
protected internal virtual IAsyncResult BeginTrack(TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) { return(new TrackAsyncResult(this, record, timeout, callback, state)); }
protected internal abstract void Track(TrackingRecord record, TimeSpan timeout);