private static void WriteActivityTrackingRecord(ActivityTrackingRecord activityTrackingRecord)
{
WriteTitle("Activity Tracking Record");
Console.WriteLine("EventDateTime: " + activityTrackingRecord.EventDateTime.ToString());
Console.WriteLine("QualifiedName: " + activityTrackingRecord.QualifiedName.ToString());
Console.WriteLine("Type: " + activityTrackingRecord.ActivityType);
Console.WriteLine("Status: " + activityTrackingRecord.ExecutionStatus.ToString());
}
private void WriteActivityTrackingRecord(ActivityTrackingRecord activityTrackingRecord)
{
var message = GetTitle("Activity Tracking Record");
message += string.Format("EventDateTime: {0}\r\n" , activityTrackingRecord.EventDateTime);
message += string.Format("QualifiedName: {0}\r\n" , activityTrackingRecord.QualifiedName);
message += string.Format("Type: {0}\r\n" , activityTrackingRecord.ActivityType);
message += string.Format("Status: {0}\r\n" , activityTrackingRecord.ExecutionStatus);
foreach (var item in activityTrackingRecord.Body)
{
message += string.Format("{0}: {1}\r\n", item.FieldName, item.Data);
}
m_Logger.Debug(message);
}
internal void ActivityStatusChange(object sender, WorkflowExecutor.ActivityStatusChangeEventArgs e)
{
WorkflowTrace.Tracking.TraceInformation("TrackingListener::ActivityStatusChange - Received Activity Status Change Event for activity {0}", new object[] { e.Activity.QualifiedName });
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
{
throw new ArgumentException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
WorkflowExecutor exec = (WorkflowExecutor) sender;
if ((this._channels == null) || (this._channels.Count <= 0))
{
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NoChannels);
}
else
{
Activity activity = e.Activity;
if (this.SubscriptionRequired(activity, exec))
{
Guid empty = Guid.Empty;
Guid contextGuid = Guid.Empty;
this.GetContext(activity, exec, out contextGuid, out empty);
DateTime utcNow = DateTime.UtcNow;
int nextEventOrderId = this._broker.GetNextEventOrderId();
foreach (TrackingChannelWrapper wrapper in this._channels)
{
ActivityTrackingRecord record = new ActivityTrackingRecord(activity.GetType(), activity.QualifiedName, contextGuid, empty, activity.ExecutionStatus, utcNow, nextEventOrderId, null);
if (wrapper.GetTrackingProfile(exec).TryTrackActivityEvent(activity, activity.ExecutionStatus, exec, record))
{
wrapper.TrackingChannel.Send(record);
}
}
}
}
}
internal bool TryTrackActivityEvent(Activity activity, ActivityExecutionStatus status, IServiceProvider provider, ActivityTrackingRecord record)
{
List<ActivityTrackPointCacheItem> points;
//
// Check the match caches.
if (TryGetCacheItems(activity, out points))
{
bool ret = false;
foreach (ActivityTrackPointCacheItem item in points)
{
if (item.HasLocationConditions)
{
if (!item.Point.IsMatch(activity, status))
continue;
}
if (item.Events.Contains(status))
{
ret = true;
item.Point.Track(activity, provider, record.Body);
record.Annotations.AddRange(item.Point.Annotations);
}
}
return ret;
}
return false;
}
/// <summary>
/// Serialise a <see cref="ActivityTrackingRecord" /> ready for persistence.
/// </summary>
/// <param name="activityTrackingRecord">
/// The original <see cref="ActivityTrackingRecord" /> to serialise.
/// </param>
/// <returns>
/// Modified copy of the <see cref="ActivityTrackingRecord" /> containing
/// the serialised data.
/// </returns>
private static SerialisableActivityTrackingRecord buildSerialisableActivityTrackingRecord(ActivityTrackingRecord activityTrackingRecord)
{
SerialisableActivityTrackingRecord serialisableActivityTrackingRecord = new SerialisableActivityTrackingRecord();
serialisableActivityTrackingRecord.ActivityType = activityTrackingRecord.ActivityType;
serialisableActivityTrackingRecord.Annotations.AddRange(activityTrackingRecord.Annotations);
serialisableActivityTrackingRecord.ContextGuid = activityTrackingRecord.ContextGuid;
serialisableActivityTrackingRecord.EventDateTime = activityTrackingRecord.EventDateTime;
serialisableActivityTrackingRecord.EventOrder = activityTrackingRecord.EventOrder;
serialisableActivityTrackingRecord.ExecutionStatus = activityTrackingRecord.ExecutionStatus;
serialisableActivityTrackingRecord.ParentContextGuid = activityTrackingRecord.ParentContextGuid;
serialisableActivityTrackingRecord.QualifiedName = activityTrackingRecord.QualifiedName;
if (activityTrackingRecord.Body != null)
{
for (int i = 0; i < activityTrackingRecord.Body.Count; i++)
serialisableActivityTrackingRecord.Body.Add(buildSerialisableTrackingDataItem(activityTrackingRecord.Body[i]));
}
if (activityTrackingRecord.EventArgs != null)
serialisableActivityTrackingRecord.EventArgs = buildSerialisableData(activityTrackingRecord.EventArgs);
return serialisableActivityTrackingRecord;
}
internal bool TryTrackActivityEvent(Activity activity, ActivityExecutionStatus status, IServiceProvider provider, ActivityTrackingRecord record)
{
List<ActivityTrackPointCacheItem> list;
if (!this.TryGetCacheItems(activity, out list))
{
return false;
}
bool flag = false;
foreach (ActivityTrackPointCacheItem item in list)
{
if ((!item.HasLocationConditions || item.Point.IsMatch(activity, status)) && item.Events.Contains(status))
{
flag = true;
item.Point.Track(activity, provider, record.Body);
record.Annotations.AddRange(item.Point.Annotations);
}
}
return flag;
}
private void LoadActivityEventsFromReader(SqlDataReader reader, object parameter)
{
if (null == reader)
{
throw new ArgumentNullException("reader");
}
//
// There should always be 4 recordsets in this reader!
//
Dictionary <long, ActivityTrackingRecord> activities = new Dictionary <long, ActivityTrackingRecord>();
//
// Build a dictionary of activity records so that we can match
// annotation and artifact records from subsequent recordsets
DateTime tmpMin = SqlDateTime.MinValue.Value;
while (reader.Read())
{
string qId = reader.GetString(0);
ActivityExecutionStatus status = (ActivityExecutionStatus)reader[1];
DateTime dt = reader.GetDateTime(2);
Guid context = reader.GetGuid(3), parentContext = reader.GetGuid(4);
int order = reader.GetInt32(5);
if (reader.IsDBNull(6) || reader.IsDBNull(7))
{
throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentCulture, ExecutionStringManager.SqlTrackingTypeNotFound, qId));
}
Type type = Type.GetType(reader.GetString(6) + ", " + reader.GetString(7), true, false);
long eventId = reader.GetInt64(8);
DateTime dbDt = reader.GetDateTime(9);
activities.Add(eventId, new ActivityTrackingRecord(type, qId, context, parentContext, status, dt, order, null));
if (dbDt > tmpMin)
{
tmpMin = dbDt;
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
//
// If we have annotations on the event itself, add them
while (reader.Read())
{
long eventId = reader.GetInt64(0);
string annotation = null;
if (!reader.IsDBNull(1))
{
annotation = reader.GetString(1);
}
ActivityTrackingRecord activity = null;
if (activities.TryGetValue(eventId, out activity))
{
if (null != activity)
{
activity.Annotations.Add(annotation);
}
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
//
// Build a dictionary of artifact records so that we can match
// annotation records from subsequent recordsets
BinaryFormatter formatter = new BinaryFormatter();
Dictionary <long, TrackingDataItem> artifacts = new Dictionary <long, TrackingDataItem>();
while (reader.Read())
{
long eventId = reader.GetInt64(0);
long artId = reader.GetInt64(1);
string name = reader.GetString(2), strData = null;
object data = null;
//
// These may both be null
if (!reader.IsDBNull(3))
{
strData = reader.GetString(3);
}
if (!reader.IsDBNull(4))
{
data = formatter.Deserialize(new MemoryStream((Byte[])reader[4]));
}
TrackingDataItem item = new TrackingDataItem();
item.FieldName = name;
if (null != data)
{
item.Data = data;
}
else
{
item.Data = strData;
}
artifacts.Add(artId, item);
//
// Find the event to which this artifact belongs and add it to the record
ActivityTrackingRecord activity = null;
if (activities.TryGetValue(eventId, out activity))
{
if (null != activity)
{
activity.Body.Add(item);
}
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
//
// If we have annotations add them to the appropriate artifact
while (reader.Read())
{
long artId = reader.GetInt64(0);
string annotation = null;
if (!reader.IsDBNull(1))
{
annotation = reader.GetString(1);
}
//
// Find the right artifact and give it the annotation
TrackingDataItem item = null;
if (artifacts.TryGetValue(artId, out item))
{
if (null != item)
{
item.Annotations.Add(annotation);
}
}
}
_activityEvents.AddRange(activities.Values);
//
// Set the min value to the most recent event that we got with this query
// Don't overwrite the previous min if nothing came back for this query
if (tmpMin > SqlDateTime.MinValue.Value)
{
_actMinDT = tmpMin;
}
return;
}
private void LoadActivityEventsFromReader(SqlDataReader reader, object parameter)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Dictionary <long, ActivityTrackingRecord> dictionary = new Dictionary <long, ActivityTrackingRecord>();
DateTime time = SqlDateTime.MinValue.Value;
while (reader.Read())
{
string qualifiedName = reader.GetString(0);
ActivityExecutionStatus executionStatus = (ActivityExecutionStatus)reader[1];
DateTime dateTime = reader.GetDateTime(2);
Guid contextGuid = reader.GetGuid(3);
Guid guid = reader.GetGuid(4);
int eventOrder = reader.GetInt32(5);
if (reader.IsDBNull(6) || reader.IsDBNull(7))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.SqlTrackingTypeNotFound, new object[] { qualifiedName }));
}
Type activityType = Type.GetType(reader.GetString(6) + ", " + reader.GetString(7), true, false);
long key = reader.GetInt64(8);
DateTime time3 = reader.GetDateTime(9);
dictionary.Add(key, new ActivityTrackingRecord(activityType, qualifiedName, contextGuid, guid, executionStatus, dateTime, eventOrder, null));
if (time3 > time)
{
time = time3;
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
while (reader.Read())
{
long num3 = reader.GetInt64(0);
string str2 = null;
if (!reader.IsDBNull(1))
{
str2 = reader.GetString(1);
}
ActivityTrackingRecord record = null;
if (dictionary.TryGetValue(num3, out record) && (record != null))
{
record.Annotations.Add(str2);
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
BinaryFormatter formatter = new BinaryFormatter();
Dictionary <long, TrackingDataItem> dictionary2 = new Dictionary <long, TrackingDataItem>();
while (reader.Read())
{
long num4 = reader.GetInt64(0);
long num5 = reader.GetInt64(1);
string str3 = reader.GetString(2);
string str4 = null;
object obj2 = null;
if (!reader.IsDBNull(3))
{
str4 = reader.GetString(3);
}
if (!reader.IsDBNull(4))
{
obj2 = formatter.Deserialize(new MemoryStream((byte[])reader[4]));
}
TrackingDataItem item = new TrackingDataItem {
FieldName = str3
};
if (obj2 != null)
{
item.Data = obj2;
}
else
{
item.Data = str4;
}
dictionary2.Add(num5, item);
ActivityTrackingRecord record2 = null;
if (dictionary.TryGetValue(num4, out record2) && (record2 != null))
{
record2.Body.Add(item);
}
}
if (!reader.NextResult())
{
throw new ArgumentException(ExecutionStringManager.InvalidActivityEventReader);
}
while (reader.Read())
{
long num6 = reader.GetInt64(0);
string str5 = null;
if (!reader.IsDBNull(1))
{
str5 = reader.GetString(1);
}
TrackingDataItem item2 = null;
if (dictionary2.TryGetValue(num6, out item2) && (item2 != null))
{
item2.Annotations.Add(str5);
}
}
this._activityEvents.AddRange(dictionary.Values);
if (time > SqlDateTime.MinValue.Value)
{
this._actMinDT = time;
}
}
private void WriteActivityTrackingRecord(ActivityTrackingRecord activityTrackingRecord)
{
WriteToFile("Activity: " + activityTrackingRecord.QualifiedName.ToString() + " " + activityTrackingRecord.ExecutionStatus.ToString());
}
