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 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);
}
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);
