private void TrackWorkflowInstanceRecord(WorkflowInstanceRecord record)
{
if (record.WorkflowDefinitionIdentity == null)
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceRecordIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceRecord(record.InstanceId, record.RecordNumber,
record.EventTime, record.ActivityDefinitionId,
record.State,
record.HasAnnotations ? JsonConvert.SerializeObject(record.Annotations, Formatting.Indented) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name, this.ApplicationReference);
}
}
else
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceRecordWithIdIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceRecordWithId(record.InstanceId, record.RecordNumber,
record.EventTime, record.ActivityDefinitionId,
record.State,
record.HasAnnotations ? JsonConvert.SerializeObject(record.Annotations, Formatting.Indented) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name == null ? string.Empty : this.TrackingProfile.Name,
record.WorkflowDefinitionIdentity.ToString(), this.ApplicationReference);
}
}
}
public void Track(WorkflowInstanceRecord instanceRecord)
{
if (this.instance.HasTrackingParticipant)
{
this.instance.TrackingProvider.AddRecord(instanceRecord);
}
}
private void ProcessInstRecord(WorkflowInstanceRecord wfInstRecord)
{
if (wfInstRecord.State == WorkflowInstanceStates.Completed ||
wfInstRecord.State == WorkflowInstanceStates.UnhandledException ||
wfInstRecord.State == WorkflowInstanceStates.Terminated ||
wfInstRecord.State == WorkflowInstanceStates.Aborted)
{
WorkItemWithHistory rootWorkItemForWorkflowInstance =
_activeWorkItemsLogs.GetRootWorkItemForWorkflowInstance(wfInstRecord.InstanceId);
if (rootWorkItemForWorkflowInstance == null)
{
return;
}
Guid workItemRootId = rootWorkItemForWorkflowInstance.Id;
if (_onInstanceRemoved != null)
{
_onInstanceRemoved(workItemRootId, new WorkItemWithHistory());
}
_activeWorkItemsLogs.UnregisterWorkflowInstance(wfInstRecord.InstanceId, _messageIndex++);
if (ProgressObserver != null)
{
//jlin may need to turn on
// ProgressObserver.UnregisterWorkItemsWithHistoryTree(workItemRootId, _messageIndex);
}
}
}
private void ProcessWorkflowInstanceRecord(WorkflowInstanceRecord record)
{
object[] instanceId = new object[2];
instanceId[0] = record.InstanceId;
instanceId[1] = record.State;
this.Tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, " Workflow InstanceID: {0} Workflow instance state: {1}", instanceId));
}
private void TrackWorkflowInstanceUnhandledExceptionRecord(WorkflowInstanceRecord record)
{
WorkflowInstanceUnhandledExceptionRecord unhandled = record as WorkflowInstanceUnhandledExceptionRecord;
if (unhandled.WorkflowDefinitionIdentity == null)
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceUnhandledExceptionRecordIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceUnhandledExceptionRecord(unhandled.InstanceId,
unhandled.RecordNumber, unhandled.EventTime, unhandled.ActivityDefinitionId,
unhandled.FaultSource.Name, unhandled.FaultSource.Id, unhandled.FaultSource.InstanceId, unhandled.FaultSource.TypeName,
unhandled.UnhandledException == null ? string.Empty : unhandled.UnhandledException.ToString(),
unhandled.HasAnnotations ? JsonConvert.SerializeObject(unhandled.Annotations, Formatting.Indented) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name, this.ApplicationReference);
}
}
else
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceUnhandledExceptionRecordWithIdIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceUnhandledExceptionRecordWithId(unhandled.InstanceId,
unhandled.RecordNumber, unhandled.EventTime, unhandled.ActivityDefinitionId,
unhandled.FaultSource.Name, unhandled.FaultSource.Id, unhandled.FaultSource.InstanceId, unhandled.FaultSource.TypeName,
unhandled.UnhandledException == null ? string.Empty : unhandled.UnhandledException.ToString(),
unhandled.HasAnnotations ? JsonConvert.SerializeObject(unhandled.Annotations, Formatting.Indented) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name ?? string.Empty,
unhandled.WorkflowDefinitionIdentity.ToString(), this.ApplicationReference);
}
}
}
public TrackingCommand(TrackingRecord record)
: this()
{
ActivityScheduledRecord activityScheduledRecord = record as ActivityScheduledRecord;
if (activityScheduledRecord != null)
{
CreateTrackingCommand(activityScheduledRecord);
return;
}
CancelRequestedRecord cancelRequestedRecord = record as CancelRequestedRecord;
if (cancelRequestedRecord != null)
{
CreateTrackingCommand(cancelRequestedRecord);
return;
}
FaultPropagationRecord faultPropagationRecord = record as FaultPropagationRecord;
if (faultPropagationRecord != null)
{
CreateTrackingCommand(faultPropagationRecord);
return;
}
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if (activityStateRecord != null)
{
CreateTrackingCommand(activityStateRecord);
return;
}
WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord;
if (workflowInstanceRecord != null)
{
CreateTrackingCommand(workflowInstanceRecord);
return;
}
BookmarkResumptionRecord bookmarkResumptionRecord = record as BookmarkResumptionRecord;
if (bookmarkResumptionRecord != null)
{
CreateTrackingCommand(bookmarkResumptionRecord);
return;
}
CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord;
if (customTrackingRecord != null)
{
CreateTrackingCommand(customTrackingRecord);
return;
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Console.ForegroundColor = ConsoleColor.Cyan;
if (record is ActivityScheduledRecord)
{
ActivityScheduledRecord actSchedule = record as ActivityScheduledRecord;
Console.WriteLine("Name: {0}, Scheduled", actSchedule.Child.Name);
}
else if (record is ActivityStateRecord)
{
ActivityStateRecord actState = record as ActivityStateRecord;
Console.WriteLine("Name: {0}, {1}", actState.Activity.Name, actState.State);
}
else if (record is WorkflowInstanceRecord)
{
WorkflowInstanceRecord wInstanceRecord = record as WorkflowInstanceRecord;
Console.WriteLine("WorkFlow, {0}", wInstanceRecord.State);
}
else
{
Console.WriteLine(record.ToString());
}
Console.ResetColor();
}
private void TrackWorkflowInstanceRecord(WorkflowInstanceRecord workflowInstanceRecord, ActualTrace _trace)
{
WorkflowInstanceState workflowInstanceState = (WorkflowInstanceState)Enum.Parse(typeof(WorkflowInstanceState), workflowInstanceRecord.State);
WorkflowInstanceTrace workflowInstanceTrace = new WorkflowInstanceTrace(workflowInstanceRecord.InstanceId, workflowInstanceRecord.WorkflowDefinitionIdentity, workflowInstanceState);
_trace.Add(workflowInstanceTrace);
}
private void TrackWorkflowRecord(WorkflowInstanceRecord record)
{
// In the TrackWorkflowInstance*Record methods below there are two code paths.
// If the WorkflowIdentity is null, then we follow the exisiting 4.0 path.
// If the WorkflowIdentity is provided, then if a particular field in the workflowInstance
// record is null, we need to ensure that we are passing string.Empty.
// The WriteEvent method on the DiagnosticEventProvider which is called in the
// WriteEtwEvent in the EtwTrackingParticipantRecords class invokes the EventWrite
// native method which relies on getting the record arguments in a particular order.
if (record is WorkflowInstanceUnhandledExceptionRecord)
{
TrackWorkflowInstanceUnhandledExceptionRecord(record);
}
else if (record is WorkflowInstanceAbortedRecord)
{
TrackWorkflowInstanceAbortedRecord(record);
}
else if (record is WorkflowInstanceSuspendedRecord)
{
TrackWorkflowInstanceSuspendedRecord(record);
}
else if (record is WorkflowInstanceTerminatedRecord)
{
TrackWorkflowInstanceTerminatedRecord(record);
}
else
{
TrackWorkflowInstanceRecord(record);
}
}
/// <summary>
/// Tracks the workflow instance terminated record.
/// </summary>
/// <param name="record">The record.</param>
private void TrackWorkflowInstanceTerminatedRecord(WorkflowInstanceRecord record)
{
var terminated = record as WorkflowInstanceTerminatedRecord;
if (terminated.WorkflowDefinitionIdentity == null)
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceTerminatedRecordIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceTerminatedRecord(terminated.InstanceId, terminated.RecordNumber,
terminated.EventTime, terminated.ActivityDefinitionId, terminated.Reason,
terminated.HasAnnotations ? JsonSerializer.Serialize(terminated.Annotations, new JsonSerializerOptions {
WriteIndented = true
}) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name, this.ApplicationReference);
}
}
else
{
if (WfEtwTrackingEventSource.Instance.WorkflowInstanceTerminatedRecordWithIdIsEnabled())
{
WfEtwTrackingEventSource.Instance.WorkflowInstanceTerminatedRecordWithId(terminated.InstanceId, terminated.RecordNumber,
terminated.EventTime, terminated.ActivityDefinitionId, terminated.Reason,
terminated.HasAnnotations ? JsonSerializer.Serialize(terminated.Annotations, new JsonSerializerOptions {
WriteIndented = true
}) : emptyItemsTag,
this.TrackingProfile == null ? string.Empty : this.TrackingProfile.Name ?? string.Empty,
terminated.WorkflowDefinitionIdentity.ToString(), this.ApplicationReference);
}
}
}
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]));
}
}
}
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);
}
}
/// <summary>
/// Retreive each type of tracking record and perform the corresponding fucntionality.
/// </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 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 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();
}
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();
}
}
}
/// <summary>
/// Processes WorkflowInstanceRecords to notify the view model of PowerOn/Off events
/// </summary>
/// <param name="workflowInstanceRecord">
/// The workflow instance record.
/// </param>
private void ProcessWorkflowInstanceRecord(WorkflowInstanceRecord workflowInstanceRecord)
{
switch (workflowInstanceRecord.State)
{
case "Started":
this.atmViewModel.Notify(AtmTransition.PowerOn, null);
break;
case "Completed":
this.atmViewModel.Notify(AtmTransition.PowerOff, null);
break;
case "Canceled":
this.atmViewModel.Notify(AtmTransition.PowerOff, null);
break;
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
WorkflowInstanceRecord instanceRecord = record as WorkflowInstanceRecord;
if (instanceRecord != null)
{
this.InstanceStates.Add(instanceRecord.State);
return;
}
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if (activityStateRecord != null)
{
this.ActivityStates.Add(Colonize(activityStateRecord.Activity.Name, activityStateRecord.State));
return;
}
CustomTrackingRecord customRecord = record as CustomTrackingRecord;
if (customRecord != null)
{
foreach (KeyValuePair <string, object> kvp in customRecord.Data)
{
this.CustomRecords.Add(Colonize(kvp.Key, kvp.Value.ToString()));
}
return;
}
BookmarkResumptionRecord bookmarkRecord = record as BookmarkResumptionRecord;
if (bookmarkRecord != null)
{
this.BookmarkResumptionRecords.Add(Colonize(bookmarkRecord.BookmarkName, bookmarkRecord.Payload.ToString()));
return;
}
ActivityScheduledRecord scheduledRecord = record as ActivityScheduledRecord;
if (scheduledRecord != null)
{
// For the root activity, the "parent" will be null, so tolerate that case.
this.ActivityScheduledRecords.Add(Colonize((scheduledRecord.Activity != null) ? scheduledRecord.Activity.Name : "<null>", scheduledRecord.Child.Name));
return;
}
}
private void LogWorkflowRecord(WorkflowInstanceRecord record)
{
Contract.Requires(null != record);
var annotations = JsonConvert.SerializeObject(record.Annotations, Formatting.Indented);
var workflowDefinitionIdentity = JsonConvert.SerializeObject(record.WorkflowDefinitionIdentity, Formatting.Indented);
Logger.Get(_loggingTrackingParticipantSettings.TraceSourceName)
.TraceInformation("{0} {1} {2} - InstanceId = '{3}', Annotations = '{4}', ActivityDefinitionId = '{5}', State = '{6}', WorkflowDefinitionIdentity = '{7}'",
record.GetType().Name,
record.EventTime,
record.Level,
record.InstanceId,
annotations,
record.ActivityDefinitionId,
record.State,
workflowDefinitionIdentity
);
}
public 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(ActivityTrackingRecord))
{
ActivityTrackingRecord crecord = (ActivityTrackingRecord)record;
RecordWriteLine(crecord, "Activity, " + crecord.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)
{
lock (this)
{
WorkflowInstanceUnhandledExceptionRecord unhandledExceptionRecord =
record as WorkflowInstanceUnhandledExceptionRecord;
if (unhandledExceptionRecord != null)
{
ProcessInstRecord(unhandledExceptionRecord);
Console.WriteLine("Exception executing workflow " + unhandledExceptionRecord);
return;
}
WorkflowInstanceRecord wfInstRecord = record as WorkflowInstanceRecord;
if (wfInstRecord != null)
{
ProcessInstRecord(wfInstRecord);
return;
}
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if (activityStateRecord != null)
{
ProcessActivityStateRecord(activityStateRecord);
return;
}
FaultPropagationRecord faultPropagationRecord = record as FaultPropagationRecord;
if (faultPropagationRecord != null)
{
ProcessFaultPropagationRecord(faultPropagationRecord);
return;
}
CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord;
if (customTrackingRecord != null)
{
ProcessCustomTrackingRecord(customTrackingRecord);
return;
}
}
}
void CreateTrackingCommand(WorkflowInstanceRecord record)
{
this.Procedure = "[MOJ.WorkflowManger.Tracking].[InsertWorkflowInstanceEvent]";
this.parameters.Add(CreateTrackingCommandParameter("@WorkflowInstanceId", SqlDbType.UniqueIdentifier, null, record.InstanceId));
this.parameters.Add(CreateTrackingCommandParameter("@WorkflowActivityDefinition", SqlDbType.NVarChar, 256, record.ActivityDefinitionId));
this.parameters.Add(CreateTrackingCommandParameter("@RecordNumber", SqlDbType.BigInt, null, record.RecordNumber));
this.parameters.Add(CreateTrackingCommandParameter("@State", SqlDbType.NVarChar, 128, record.State));
this.parameters.Add(CreateTrackingCommandParameter("@TraceLevelId", SqlDbType.TinyInt, null, record.Level));
this.parameters.Add(CreateTrackingCommandParameter("@AnnotationsXml", SqlDbType.NVarChar, null, this.SerializeData(record.Annotations)));
this.parameters.Add(CreateTrackingCommandParameter("@TimeCreated", SqlDbType.DateTime, null, record.EventTime));
if (record is WorkflowInstanceUnhandledExceptionRecord)
{
this.parameters.Add(CreateTrackingCommandParameter("@ExceptionDetails", SqlDbType.NVarChar, null, ((WorkflowInstanceUnhandledExceptionRecord)record).UnhandledException.ToString()));
}
else
{
this.parameters.Add(CreateTrackingCommandParameter("@ExceptionDetails", SqlDbType.NVarChar, null, DBNull.Value));
}
if (record is WorkflowInstanceTerminatedRecord)
{
this.parameters.Add(CreateTrackingCommandParameter("@Reason", SqlDbType.NVarChar, null, ((WorkflowInstanceTerminatedRecord)record).Reason));
}
else
{
if (record is WorkflowInstanceAbortedRecord)
{
this.parameters.Add(CreateTrackingCommandParameter("@Reason", SqlDbType.NVarChar, null, ((WorkflowInstanceAbortedRecord)record).Reason));
}
else if (record is WorkflowInstanceSuspendedRecord)
{
this.parameters.Add(CreateTrackingCommandParameter("@Reason", SqlDbType.NVarChar, null, ((WorkflowInstanceSuspendedRecord)record).Reason));
}
else
{
this.parameters.Add(CreateTrackingCommandParameter("@Reason", SqlDbType.NVarChar, null, DBNull.Value));
}
}
}
public void OnMessage(Message <byte[]> message)
{
WorkflowInstanceRecord value = WorkflowInstanceRecord.Parser.ParseFrom(message.GetMessageObject());
MessageConsumer.Invoke(value);
}
public void Track(WorkflowInstanceRecord instanceRecord)
{
throw new NotImplementedException();
}
protected override void Track(TrackingRecord trackRecord, TimeSpan timeStamp)
{
try
{
string State = "unknown";
Guid InstanceId = trackRecord.InstanceId;
ActivityStateRecord activityStateRecord = trackRecord as ActivityStateRecord;
ActivityScheduledRecord activityScheduledRecord = trackRecord as ActivityScheduledRecord;
WorkflowInstanceRecord workflowInstanceRecord = trackRecord as WorkflowInstanceRecord;
if (workflowInstanceRecord != null)
{
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (workflowInstanceRecord.State == WorkflowInstanceStates.Started || workflowInstanceRecord.State == WorkflowInstanceStates.Resumed)
{
lock (timerslock) timers.Add(InstanceId.ToString(), new Dictionary <string, Stopwatch>());
System.Diagnostics.Activity.Current = null;
// Instance.RootActivity = Instance.source.StartActivity(workflowInstanceRecord.State.ToString() + " " + Instance.Workflow.name, ActivityKind.Consumer, Instance.ParentSpanId);
Instance.RootActivity = Instance.source.StartActivity(workflowInstanceRecord.State.ToString() + " " + Instance.Workflow.name, ActivityKind.Consumer);
if (Instance.RootActivity != null)
{
if (!string.IsNullOrEmpty(Instance.ParentSpanId))
{
Instance.RootActivity?.SetParentId(Instance.ParentSpanId);
}
Instance.SpanId = Instance.RootActivity.SpanId.ToHexString();
}
Instance.RootActivity?.SetTag("status.code", 200);
Instance.RootActivity?.SetTag("status.state", workflowInstanceRecord.State.ToString());
Instance.RootActivity?.SetTag("ofid", Config.local.openflow_uniqueid);
try
{
if (global.webSocketClient != null && global.webSocketClient.user != null && !string.IsNullOrEmpty(global.webSocketClient.user.username))
{
Instance.RootActivity?.SetTag("username", global.webSocketClient.user.username);
}
else
{
Instance.RootActivity?.SetTag("username", System.Security.Principal.WindowsIdentity.GetCurrent().Name);
}
}
catch (Exception)
{
}
try
{
if (hostname == null)
{
hostname = System.Net.Dns.GetHostName();
}
Instance.RootActivity?.SetTag("hostname", hostname);
}
catch (Exception)
{
hostname = "";
}
Instance.Activities.Push(Instance.RootActivity);
}
else if (workflowInstanceRecord.State == WorkflowInstanceStates.Aborted || workflowInstanceRecord.State == WorkflowInstanceStates.Canceled ||
workflowInstanceRecord.State == WorkflowInstanceStates.Completed || workflowInstanceRecord.State == WorkflowInstanceStates.Deleted ||
workflowInstanceRecord.State == WorkflowInstanceStates.Suspended || workflowInstanceRecord.State == WorkflowInstanceStates.Terminated ||
workflowInstanceRecord.State == WorkflowInstanceStates.UnhandledException || workflowInstanceRecord.State == WorkflowInstanceStates.UpdateFailed)
{
if (timers.ContainsKey(InstanceId.ToString()))
{
lock (timerslock) timers.Remove(InstanceId.ToString());
}
if (workflowInstanceRecord.State != WorkflowInstanceStates.Completed)
{
Instance.RootActivity?.SetTag("status.state", 500);
}
if (workflowInstanceRecord.State == WorkflowInstanceStates.UnhandledException)
{
Instance.RootActivity?.SetTag("Exception", ((System.Activities.Tracking.WorkflowInstanceUnhandledExceptionRecord)workflowInstanceRecord).UnhandledException);
}
if (workflowInstanceRecord.State == WorkflowInstanceStates.Aborted)
{
Instance.RootActivity?.SetTag("Reason", ((System.Activities.Tracking.WorkflowInstanceAbortedRecord)workflowInstanceRecord).Reason);
}
if (workflowInstanceRecord.State == WorkflowInstanceStates.Suspended)
{
Instance.RootActivity?.SetTag("Reason", ((System.Activities.Tracking.WorkflowInstanceSuspendedRecord)workflowInstanceRecord).Reason);
}
if (workflowInstanceRecord.State == WorkflowInstanceStates.Terminated)
{
Instance.RootActivity?.SetTag("Reason", ((System.Activities.Tracking.WorkflowInstanceTerminatedRecord)workflowInstanceRecord).Reason);
}
Instance.RootActivity?.SetTag("status.state", workflowInstanceRecord.State.ToString());
if (Instance.source != null)
{
while (Instance.Activities.Count > 0)
{
var span = Instance.Activities.Pop();
span?.Dispose();
}
Instance.RootActivity = null;
}
}
else
{
Instance.RootActivity?.AddEvent(new ActivityEvent(workflowInstanceRecord.State.ToString()));
if (Instance.Activities.Count > 0)
{
Instance.Activities.First()?.AddEvent(new ActivityEvent(workflowInstanceRecord.State.ToString()));
}
}
}
//if (activityStateRecord != null || activityScheduledRecord != null)
if (activityStateRecord != null)
{
string ActivityId = null, name = null;
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Id))
{
ActivityId = activityStateRecord.Activity.Id;
}
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Name))
{
name = activityStateRecord.Activity.Name;
}
Console.WriteLine(activityStateRecord.State.ToString() + " " + ActivityId + " " + name);
// var sw = new Stopwatch(); sw.Start();
if (timers.ContainsKey(InstanceId.ToString()) && !string.IsNullOrEmpty(ActivityId))
{
var timer = timers[InstanceId.ToString()];
if (activityStateRecord.State == ActivityStates.Executing)
{
if (!timer.ContainsKey(ActivityId))
{
Stopwatch sw = new Stopwatch(); sw.Start();
timer.Add(ActivityId, sw);
var TypeName = activityStateRecord.Activity.TypeName;
var Name = activityStateRecord.Activity.Name;
if (String.IsNullOrEmpty(Name))
{
Name = TypeName;
}
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
System.Diagnostics.Activity.Current = Instance.RootActivity;
var span = Instance.source.StartActivity(Name, ActivityKind.Consumer);
span?.AddTag("type", TypeName);
span?.AddTag("ActivityId", ActivityId);
// Console.WriteLine("Push " + Name);
if (Instance.source != null)
{
Instance.Activities.Push(span);
}
// Console.WriteLine("start " + TypeName);
}
else
{
// Console.WriteLine("Skip adding new span and timer for " + ActivityId);
}
}
if (activityStateRecord.State != ActivityStates.Executing)
{
if (timer.ContainsKey(ActivityId))
{
Stopwatch sw = timer[ActivityId];
timer.Remove(ActivityId);
var TypeName = activityStateRecord.Activity.TypeName;
var Name = activityStateRecord.Activity.Name;
if (String.IsNullOrEmpty(Name))
{
Name = TypeName;
}
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
try
{
if (Instance.Activities.Count > 0)
{
if (Instance.Activities.First().DisplayName == Name)
{
// Console.WriteLine("Popping " + Name);
var span = Instance.Activities.Pop();
span?.Dispose();
}
else
{
// Console.WriteLine("Skip pop, expected " + Name + " but found " + Instance.Activities.First().DisplayName);
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
else
{
// Console.WriteLine("Skip removing old span and timer for " + ActivityId);
}
}
}
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Name) && Instance != null && Instance.Workflow != null)
{
var TypeName = activityStateRecord.Activity.TypeName;
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
//RobotInstance.activity_counter.WithLabels((activityStateRecord.Activity.Name, TypeName, Instance.Workflow.name)).Inc();
}
foreach (var v in activityStateRecord.Variables)
{
if (Instance.Variables.ContainsKey(v.Key))
{
Instance.Variables[v.Key].value = v.Value;
}
else
{
if (v.Value != null)
{
Instance.Variables.Add(v.Key, new WorkflowInstanceValueType(v.Value.GetType(), v.Value));
}
}
//wfi.variables.Add(v.Key, v.Value);
}
// Log.Activity(activityStateRecord.State + " " + activityStateRecord.Activity.Id + " " + activityStateRecord.Activity.Name);
}
if (activityScheduledRecord != null)
{
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (Instance == null || Instance.wfApp == null)
{
return;
}
var wfApp = Instance.wfApp;
var executor = typeof(System.Activities.Hosting.WorkflowInstance).GetField("executor", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(wfApp);
var scheduler = executor.GetType().GetField("scheduler", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor);
string ActivityId = null;
string ChildActivityId = null;
if (activityStateRecord != null)
{
ActivityId = activityStateRecord.Activity.Id;
State = activityStateRecord.State.ToLower();
}
if (activityScheduledRecord != null)
{
State = "Scheduled";
if (activityScheduledRecord.Activity != null)
{
ActivityId = activityScheduledRecord.Activity.Id;
}
if (activityScheduledRecord.Child != null)
{
ChildActivityId = activityScheduledRecord.Child.Id;
}
}
if (activityScheduledRecord.Activity == null && activityScheduledRecord.Child != null)
{
// this will make "1" be handles twice, but "1" is always sendt AFTER being scheduled, but we can catch it here ?
ActivityId = activityScheduledRecord.Child.Id;
ChildActivityId = activityScheduledRecord.Child.Id;
}
if (string.IsNullOrEmpty(ActivityId))
{
return;
}
if (activityScheduledRecord.Child.Id == "1.11")
{
// scheduler.GetType().GetMethod("ClearAllWorkItems", BindingFlags.Public | BindingFlags.Instance).Invoke(scheduler, new object[] { executor });
// scheduler.GetType().GetMethod("ScheduleWork", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(scheduler, new object[] { false });
//var firstWorkItem = scheduler.GetType().GetField("firstWorkItem", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(scheduler);
//firstWorkItem.GetType().GetMethod("Release", BindingFlags.Public | BindingFlags.Instance).Invoke(firstWorkItem, new object[] { executor });
//firstWorkItem.GetType().GetMethod("Dispose", BindingFlags.Public | BindingFlags.Instance).Invoke(firstWorkItem, new object[] { executor });
//scheduler.GetType().GetMethod("NotifyWorkCompletion", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(scheduler, new object[] { });
}
if (activityScheduledRecord.Activity != null)
{
// Log.Activity("Scheduled " + activityScheduledRecord.Activity.Id + " " + activityScheduledRecord.Activity.Name + " -> " + activityScheduledRecord.Child.Id + " " + activityScheduledRecord.Child.Name);
}
else if (activityScheduledRecord.Child != null)
{
// Log.Activity("Scheduled " + activityScheduledRecord.Child.Id + " " + activityScheduledRecord.Child.Name);
}
if (Instance.Variables == null)
{
Instance.Variables = new Dictionary <string, WorkflowInstanceValueType>();
}
if (activityStateRecord != null)
{
foreach (var v in Instance.Variables.ToList())
{
if (!activityStateRecord.Variables.ContainsKey(v.Key))
{
Instance.Variables.Remove(v.Key);
}
}
foreach (var v in activityStateRecord.Variables)
{
if (Instance.Variables.ContainsKey(v.Key))
{
Instance.Variables[v.Key].value = v.Value;
}
}
}
var instanceMapField = executor.GetType().GetField("instanceMap", BindingFlags.NonPublic | BindingFlags.Instance);
// get SerializedProgramMapping to have InstanceMap get filled, needed by SerializedProgramMapping
var SerializedProgramMapping = executor.GetType().GetProperty("SerializedProgramMapping", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor);
ActivityInstance activityInstance = executor.GetType().GetField("rootInstance", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor) as ActivityInstance;
// Sometimes we can find the ActivityInstance in rootInstance
ActivityInstance result = findActivityInstance(executor, activityInstance, ActivityId);
// But more often, we find it in InstanceMapping
var instanceMap = instanceMapField.GetValue(executor);
if (instanceMap != null && result == null)
{
var _list = SerializedProgramMapping.GetType().GetProperty("InstanceMapping", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(SerializedProgramMapping);
foreach (System.Collections.DictionaryEntry kvp in (System.Collections.IDictionary)_list)
{
var a = kvp.Key as System.Activities.Activity;
if (a == null)
{
continue;
}
if (result == null && a.Id == ActivityId)
{
result = findActivityInstance(kvp.Value, ActivityId);
}
}
}
if (result != null)
{
WorkflowDataContext context = null;
var cs = typeof(WorkflowDataContext).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
ConstructorInfo c = cs.First();
try
{
object o = c.Invoke(new Object[] { executor, result, true });
context = o as WorkflowDataContext;
var vars = context.GetProperties();
foreach (dynamic v in vars)
{
var value = v.GetValue(context);
if (Instance.Variables.ContainsKey(v.DisplayName))
{
Instance.Variables[v.DisplayName] = new WorkflowInstanceValueType(v.PropertyType, value);
}
else
{
Instance.Variables.Add(v.DisplayName, new WorkflowInstanceValueType(v.PropertyType, value));
}
}
}
catch (Exception ex)
{
Log.Debug(ex.Message);
}
}
OnVisualTracking?.Invoke(Instance, ActivityId, ChildActivityId, State);
}
else
{
// Log.Debug(trackRecord.ToString());
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
protected override void Track(TrackingRecord trackRecord, TimeSpan timeStamp)
{
try
{
string State = "unknown";
Guid InstanceId = trackRecord.InstanceId;
ActivityStateRecord activityStateRecord = trackRecord as ActivityStateRecord;
ActivityScheduledRecord activityScheduledRecord = trackRecord as ActivityScheduledRecord;
WorkflowInstanceRecord workflowInstanceRecord = trackRecord as WorkflowInstanceRecord;
if (workflowInstanceRecord != null)
{
Log.Activity(workflowInstanceRecord.ActivityDefinitionId + " " + workflowInstanceRecord.State);
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (Instance == null)
{
return;
}
lock (Instance)
{
if (workflowInstanceRecord.State == WorkflowInstanceStates.Started || workflowInstanceRecord.State == WorkflowInstanceStates.Resumed)
{
lock (timerslock) timers.Add(InstanceId.ToString(), new Dictionary <string, Stopwatch>());
}
else if (workflowInstanceRecord.State == WorkflowInstanceStates.Aborted || workflowInstanceRecord.State == WorkflowInstanceStates.Canceled ||
workflowInstanceRecord.State == WorkflowInstanceStates.Completed || workflowInstanceRecord.State == WorkflowInstanceStates.Deleted ||
workflowInstanceRecord.State == WorkflowInstanceStates.Suspended || workflowInstanceRecord.State == WorkflowInstanceStates.Terminated ||
workflowInstanceRecord.State == WorkflowInstanceStates.UnhandledException || workflowInstanceRecord.State == WorkflowInstanceStates.UpdateFailed)
{
if (timers.ContainsKey(InstanceId.ToString()))
{
lock (timerslock) timers.Remove(InstanceId.ToString());
}
}
}
}
if (activityStateRecord != null)
{
string ActivityId = null, name = null;
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Id))
{
ActivityId = activityStateRecord.Activity.Id;
}
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Name))
{
name = activityStateRecord.Activity.Name;
}
// var sw = new Stopwatch(); sw.Start();
Log.Activity(name + " " + activityStateRecord.State);
if (timers.ContainsKey(InstanceId.ToString()) && !string.IsNullOrEmpty(ActivityId))
{
var timer = timers[InstanceId.ToString()];
if (activityStateRecord.State == ActivityStates.Executing)
{
if (!timer.ContainsKey(ActivityId))
{
Stopwatch sw = new Stopwatch(); sw.Start();
timer.Add(ActivityId, sw);
var TypeName = activityStateRecord.Activity.TypeName;
var Name = activityStateRecord.Activity.Name;
if (String.IsNullOrEmpty(Name))
{
Name = TypeName;
}
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
}
}
if (activityStateRecord.State != ActivityStates.Executing)
{
if (timer.ContainsKey(ActivityId))
{
Stopwatch sw = timer[ActivityId];
timer.Remove(ActivityId);
var TypeName = activityStateRecord.Activity.TypeName;
var Name = activityStateRecord.Activity.Name;
if (String.IsNullOrEmpty(Name))
{
Name = TypeName;
}
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
}
}
}
if (activityStateRecord.Activity != null && !string.IsNullOrEmpty(activityStateRecord.Activity.Name) && Instance != null && Instance.Workflow != null)
{
var TypeName = activityStateRecord.Activity.TypeName;
if (TypeName.IndexOf("`") > -1)
{
TypeName = TypeName.Substring(0, TypeName.IndexOf("`"));
}
}
foreach (var v in activityStateRecord.Variables)
{
if (Instance.Variables.ContainsKey(v.Key))
{
Instance.Variables[v.Key].value = v.Value;
}
else
{
if (v.Value != null)
{
Instance.Variables.Add(v.Key, new WorkflowInstanceValueType(v.Value.GetType(), v.Value));
}
}
}
}
if (activityScheduledRecord != null)
{
var Instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault();
if (Instance == null || Instance.wfApp == null)
{
return;
}
var wfApp = Instance.wfApp;
var executor = typeof(System.Activities.Hosting.WorkflowInstance).GetField("executor", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(wfApp);
var scheduler = executor.GetType().GetField("scheduler", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor);
string ActivityId = null;
string ChildActivityId = null;
if (activityStateRecord != null)
{
ActivityId = activityStateRecord.Activity.Id;
State = activityStateRecord.State.ToLower();
}
if (activityScheduledRecord != null)
{
State = "Scheduled";
if (activityScheduledRecord.Activity != null)
{
ActivityId = activityScheduledRecord.Activity.Id;
}
if (activityScheduledRecord.Child != null)
{
ChildActivityId = activityScheduledRecord.Child.Id;
}
}
if (activityScheduledRecord.Activity == null && activityScheduledRecord.Child != null)
{
// this will make "1" be handles twice, but "1" is always sendt AFTER being scheduled, but we can catch it here ?
ActivityId = activityScheduledRecord.Child.Id;
ChildActivityId = activityScheduledRecord.Child.Id;
}
if (string.IsNullOrEmpty(ActivityId))
{
return;
}
if (activityScheduledRecord.Child.Id == "1.11")
{
// scheduler.GetType().GetMethod("ClearAllWorkItems", BindingFlags.Public | BindingFlags.Instance).Invoke(scheduler, new object[] { executor });
// scheduler.GetType().GetMethod("ScheduleWork", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(scheduler, new object[] { false });
//var firstWorkItem = scheduler.GetType().GetField("firstWorkItem", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(scheduler);
//firstWorkItem.GetType().GetMethod("Release", BindingFlags.Public | BindingFlags.Instance).Invoke(firstWorkItem, new object[] { executor });
//firstWorkItem.GetType().GetMethod("Dispose", BindingFlags.Public | BindingFlags.Instance).Invoke(firstWorkItem, new object[] { executor });
//scheduler.GetType().GetMethod("NotifyWorkCompletion", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(scheduler, new object[] { });
}
if (Instance.Variables == null)
{
Instance.Variables = new Dictionary <string, WorkflowInstanceValueType>();
}
if (activityStateRecord != null)
{
foreach (var v in Instance.Variables.ToList())
{
if (!activityStateRecord.Variables.ContainsKey(v.Key))
{
Instance.Variables.Remove(v.Key);
}
}
foreach (var v in activityStateRecord.Variables)
{
if (Instance.Variables.ContainsKey(v.Key))
{
Instance.Variables[v.Key].value = v.Value;
}
}
}
var instanceMapField = executor.GetType().GetField("instanceMap", BindingFlags.NonPublic | BindingFlags.Instance);
// get SerializedProgramMapping to have InstanceMap get filled, needed by SerializedProgramMapping
var SerializedProgramMapping = executor.GetType().GetProperty("SerializedProgramMapping", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor);
ActivityInstance activityInstance = executor.GetType().GetField("rootInstance", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(executor) as ActivityInstance;
// Sometimes we can find the ActivityInstance in rootInstance
ActivityInstance result = findActivityInstance(executor, activityInstance, ActivityId);
// But more often, we find it in InstanceMapping
var instanceMap = instanceMapField.GetValue(executor);
if (instanceMap != null && result == null)
{
var _list = SerializedProgramMapping.GetType().GetProperty("InstanceMapping", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(SerializedProgramMapping);
foreach (System.Collections.DictionaryEntry kvp in (System.Collections.IDictionary)_list)
{
var a = kvp.Key as System.Activities.Activity;
if (a == null)
{
continue;
}
if (result == null && a.Id == ActivityId)
{
result = findActivityInstance(kvp.Value, ActivityId);
}
}
}
if (result != null)
{
WorkflowDataContext context = null;
var cs = typeof(WorkflowDataContext).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
ConstructorInfo c = cs.First();
try
{
object o = c.Invoke(new Object[] { executor, result, true });
context = o as WorkflowDataContext;
var vars = context.GetProperties();
foreach (dynamic v in vars)
{
var value = v.GetValue(context);
if (Instance.Variables.ContainsKey(v.DisplayName))
{
Instance.Variables[v.DisplayName] = new WorkflowInstanceValueType(v.PropertyType, value);
}
else
{
Instance.Variables.Add(v.DisplayName, new WorkflowInstanceValueType(v.PropertyType, value));
}
}
}
catch (Exception ex)
{
Log.Debug(ex.Message);
}
}
OnVisualTracking?.Invoke(Instance, ActivityId, ChildActivityId, State);
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
WorkflowRecord message = new WorkflowRecord();
message.WFId = WFIdentifier;
message.JobId = JobId;
message.EventId = (int)record.RecordNumber;
message.EventTime = record.EventTime.ToLocalTime();
message.RunId = record.InstanceId;
WorkflowInstanceRecord wfRecord = record as WorkflowInstanceRecord;
if (wfRecord != null)
{
message.State = wfRecord.State;
message.Name = WorkflowName;
if (wfRecord.State == WorkflowInstanceStates.Idle)
{
return; //do not track idle status
}
}
ActivityStateRecord actRecord = record as ActivityStateRecord;
if (actRecord != null)
{
message.State = actRecord.State;
message.Name = actRecord.Activity.Name;
if (actRecord.Activity.Name.Equals("DynamicActivity"))
{
return;
}
if (actRecord.State == ActivityStates.Executing && actRecord.Activity.TypeName == "System.Activities.Statements.WriteLine")
{
using (StringWriter writer = new StringWriter())
{
writer.Write(actRecord.Arguments["Text"]);
message.Message = writer.ToString();
writer.Close();
}
}
}
WorkflowInstanceUnhandledExceptionRecord exRecord = record as WorkflowInstanceUnhandledExceptionRecord;
if (exRecord != null)
{
message.State = exRecord.State;
message.Name = WorkflowName;
message.Message = exRecord.UnhandledException.Message;
}
CustomTrackingRecord cuRecord = record as CustomTrackingRecord;
if (cuRecord != null)
{
message.Name = cuRecord.Activity.Name;
message.State = cuRecord.Name;
message.Message = cuRecord.Data["Message"] as string;
}
logWorkflowEvents.InsertEvent(message);
}
public void PushDataToTraceManager(TrackingRecord data)
{
if (this.PushToTrackingDataManager != true)
{
return;
}
TraceEventType eventType = TraceEventType.Information;
if (data is ActivityScheduledRecord)
{
ActivityScheduledRecord record = (ActivityScheduledRecord)data;
string displayName = record.Child.Name;
if (this.TestTraceManager.TraceFilter.Contains(displayName))
{
return;
}
AddActivityTrace(eventType, record.InstanceId, displayName, ActivityInstanceState.Executing, record);
}
else if (data is ActivityStateRecord)
{
ActivityStateRecord record = (ActivityStateRecord)data;
if (TryConvertToEnum(record.State, out ActivityInstanceState state))
{
string displayName = record.Activity.Name;
if (this.TestTraceManager.TraceFilter.Contains(displayName))
{
return;
}
AddActivityTrace(eventType, record.InstanceId, displayName, state, record);
}
}
else if (data is WorkflowInstanceAbortedRecord)
{
WorkflowInstanceAbortedRecord record = (WorkflowInstanceAbortedRecord)data;
AddWorkflowInstanceAbortedTrace(eventType, record.InstanceId, record.Reason);
}
//else if (data is WorkflowInstanceUpdatedRecord)
//{
// WorkflowInstanceUpdatedRecord record = (WorkflowInstanceUpdatedRecord)data;
// AddWorkflowInstanceUpdatedTrace(eventType, record.InstanceId, record.OriginalDefinitionIdentity, record.WorkflowDefinitionIdentity, record.State, record.BlockingActivities, record.IsSuccessful);
//}
else if (data is WorkflowInstanceRecord)
{
WorkflowInstanceRecord record = (WorkflowInstanceRecord)data;
WorkflowInstanceState state = (WorkflowInstanceState)Enum.Parse(typeof(WorkflowInstanceState), record.State);
//these are new states that got added as part of the DCR = 109342, we do not contain them in the expceted states, hence
//explicitly removing them. have separate test cases to test the states.
if ((state == WorkflowInstanceState.Suspended) ||
(state == WorkflowInstanceState.Unsuspended))
{
return;
}
AddWorkflowInstanceTrace(eventType, record.InstanceId, record.WorkflowDefinitionIdentity, state);
}
else if (data is BookmarkResumptionRecord record)
{
AddBookmarkResumptionTrace(eventType, record.InstanceId, record.Owner.Name, record.BookmarkName,
record.BookmarkScope);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
WorkflowInstanceRecord instanceTrackingRecord =
record as WorkflowInstanceRecord;
if (instanceTrackingRecord != null)
{
TrackInstance t = new TrackInstance();
t.WorkflowID = instanceTrackingRecord.InstanceId;
t.Status = instanceTrackingRecord.State;
t.EventDate = DateTime.UtcNow;
// Insert a record into the TrackInstance table
LeadDataDataContext dc =
new LeadDataDataContext(_connectionString);
dc.TrackInstances.InsertOnSubmit(t);
dc.SubmitChanges();
}
BookmarkResumptionRecord bookTrackingRecord =
record as BookmarkResumptionRecord;
if (bookTrackingRecord != null)
{
TrackBookmark t = new TrackBookmark();
t.WorkflowID = bookTrackingRecord.InstanceId;
t.BookmarkName = bookTrackingRecord.BookmarkName;
t.EventDate = DateTime.UtcNow;
// Insert a record into the TrackBookmark table
LeadDataDataContext dc =
new LeadDataDataContext(_connectionString);
dc.TrackBookmarks.InsertOnSubmit(t);
dc.SubmitChanges();
}
ActivityStateRecord activityStateRecord =
record as ActivityStateRecord;
if (activityStateRecord != null)
{
TrackActivity t = new TrackActivity();
t.ActivityName = activityStateRecord.Activity.Name;
t.WorkflowID = activityStateRecord.InstanceId;
t.Status = activityStateRecord.State;
t.EventDate = DateTime.UtcNow;
// Concatenate all the variables into a string
IDictionary <String, object> variables =
activityStateRecord.Variables;
StringBuilder s = new StringBuilder();
if (variables.Count > 0)
{
foreach (KeyValuePair <string, object> v in variables)
{
s.AppendLine(String.Format("{0}: Value = [{1}]",
v.Key, v.Value));
}
}
// Store the variables string
t.Variables = s.ToString();
// Insert a record into the TrackActivity table
LeadDataDataContext dc =
new LeadDataDataContext(_connectionString);
dc.TrackActivities.InsertOnSubmit(t);
dc.SubmitChanges();
}
CustomTrackingRecord customTrackingRecord =
record as CustomTrackingRecord;
if (customTrackingRecord != null)
{
TrackCustom t = new TrackCustom();
t.WorkflowID = customTrackingRecord.InstanceId;
t.CustomEventName = customTrackingRecord.Name;
t.EventDate = DateTime.UtcNow;
// Concatenate all the user data into a string
string s = "";
if ((customTrackingRecord != null) &&
(customTrackingRecord.Data.Count > 0))
{
foreach (string data in customTrackingRecord.Data.Keys)
{
if (s.Length > 1)
{
s += "\r\n";
}
s += String.Format("{0}: Value = [{1}]", data,
customTrackingRecord.Data[data]);
}
}
t.UserData = s;
// Insert a record into the TrackUser table
LeadDataDataContext dc =
new LeadDataDataContext(_connectionString);
dc.TrackCustoms.InsertOnSubmit(t);
dc.SubmitChanges();
}
}
/// <summary>
/// Process the workflow instance record.
/// </summary>
/// <param name="record">Record representing workflow instance record.</param>
private void ProcessWorkflowInstanceRecord(WorkflowInstanceRecord record)
{
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, " Workflow InstanceID: {0} Workflow instance state: {1}", record.InstanceId, record.State));
}
