public void Invoke <T0, T1, T2, T3, T4, T5, T6, T7>(uint type, uint id, uint target, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, bool all = false)
{
EventIndex index = new EventIndex(type, id);
if (all == false)
{
if (mEventID.TryGetValue(index, out List <EventID> list))
{
for (int i = 0; i < list.Count; ++i)
{
if (mListeners.TryGetValue(list[i], out EventListener listener))
{
listener?.Invoke(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
}
}
}
else
{
EventID eventID = new EventID(index, target);
if (mListeners.TryGetValue(eventID, out EventListener listener))
{
listener?.Invoke(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
}
}
public void AddListener <T0, T1, T2, T3, T4, T5, T6, T7>(uint type, uint id, uint target, Action <T0, T1, T2, T3, T4, T5, T6, T7> call)
{
if (call == null)
{
return;
}
EventIndex index = new EventIndex(type, id);
EventID eventID = new EventID(index, target);
if (mEventID.TryGetValue(index, out List <EventID> list) == false)
{
list = new List <EventID>();
mEventID.Add(index, list);
}
if (list.Contains(eventID) == false)
{
list.Add(eventID);
}
if (mListeners.TryGetValue(eventID, out EventListener listener) == false)
{
listener = new EventListener();
mListeners.Add(eventID, listener);
}
listener.AddListener(call);
}
public void Invoke <T0, T1>(uint type, uint id, uint target, T0 arg0, T1 arg1, bool all = false)
{
EventIndex index = new EventIndex(type, id);
if (all == false)
{
if (mEventID.TryGetValue(index, out List <EventID> list))
{
for (int i = 0; i < list.Count; ++i)
{
if (mListeners.TryGetValue(list[i], out EventListener listener))
{
listener?.Invoke(arg0, arg1);
}
}
}
}
else
{
EventID eventID = new EventID(index, target);
if (mListeners.TryGetValue(eventID, out EventListener listener))
{
listener?.Invoke(arg0, arg1);
}
}
}
public void Clear(uint type, uint id, uint target, bool all = false)
{
EventIndex index = new EventIndex(type, id);
if (all)
{
if (mEventID.TryGetValue(index, out List <EventID> list))
{
for (int i = 0; i < list.Count; ++i)
{
if (mListeners.TryGetValue(list[i], out EventListener listener))
{
listener.Clear();
}
mListeners.Remove(list[i]);
}
mEventID.Remove(index);
}
}
else
{
EventID eventID = new EventID(index, target);
if (mListeners.TryGetValue(eventID, out EventListener listener))
{
listener.Clear();
}
mListeners.Remove(eventID);
}
}
public EventStats(IElasticClient elasticClient, EventIndex eventIndex, QueryBuilderRegistry queryBuilder, ILogger <EventStats> logger)
{
_elasticClient = elasticClient;
_eventIndex = eventIndex;
_queryBuilder = queryBuilder;
_logger = logger;
}
public EventRepository(ElasticRepositoryContext <PersistentEvent> context, EventIndex index) : base(context, index)
{
DisableCache();
BatchNotifications = true;
GetDocumentIdFunc = GetDocumentId;
GetDocumentIndexFunc = GetDocumentIndex;
}
/// <summary>Returns a string that represents the current object.</summary>
/// <returns>A string that represents the current object.</returns>
public override string ToString()
{
var segments = new[]
{
ParentItemHash,
((byte)WeekType).ToString(),
((byte)WeekDay).ToString(),
EventIndex.ToString(),
Place
};
return(string.Join(':', segments));
}
internal int CompareTo(EventIndex index)
{
int dateTimeCompareResult = this.Timestamp.CompareTo(index.Timestamp);
if (dateTimeCompareResult != 0)
{
return(dateTimeCompareResult);
}
if (this.TimestampDifferentiator < index.TimestampDifferentiator)
{
return(-1);
}
else if (this.TimestampDifferentiator == index.TimestampDifferentiator)
{
return(0);
}
else
{
return(1);
}
}
public ExceptionlessElasticConfiguration(
AppOptions appOptions,
IQueue <WorkItemData> workItemQueue,
JsonSerializerSettings serializerSettings,
ICacheClient cacheClient,
IMessageBus messageBus,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory
) : base(workItemQueue, cacheClient, messageBus, loggerFactory)
{
_appOptions = appOptions;
_serializerSettings = serializerSettings;
_logger.LogInformation("All new indexes will be created with {ElasticsearchNumberOfShards} Shards and {ElasticsearchNumberOfReplicas} Replicas", _appOptions.ElasticsearchOptions.NumberOfShards, _appOptions.ElasticsearchOptions.NumberOfReplicas);
AddIndex(Stacks = new StackIndex(this));
AddIndex(Events = new EventIndex(this, serviceProvider, appOptions));
AddIndex(Migrations = new MigrationIndex(this, _appOptions.ElasticsearchOptions.ScopePrefix + "migrations", appOptions.ElasticsearchOptions.NumberOfReplicas));
AddIndex(Organizations = new OrganizationIndex(this));
AddIndex(Projects = new ProjectIndex(this));
AddIndex(Tokens = new TokenIndex(this));
AddIndex(Users = new UserIndex(this));
AddIndex(WebHooks = new WebHookIndex(this));
}
public ActionResult Home(Guid id)
{
EventIndex eventInfo = new EventIndex();
eventInfo.eventInfo = db.tblEvent.Find(id);
eventInfo.eventParticipants = db.tblUserEvents.Where(e => e.tblEvent.GUID == id && !e.tblUser.tblRol.Name.Equals("Manager")).ToList();
return View(eventInfo);
}
private static string CreateDestinationFileName(string etlFileName, string additionalSuffix, bool isActiveEtl, EventIndex lastEventIndexProcessed)
{
string differentiator = string.Format(
CultureInfo.InvariantCulture,
"{0:D10}",
isActiveEtl ? lastEventIndexProcessed.TimestampDifferentiator : int.MaxValue);
string traceFileNamePrefix = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}_{2:D20}_{3}{4}.",
TestNodeId,
Path.GetFileNameWithoutExtension(etlFileName),
lastEventIndexProcessed.Timestamp.Ticks,
differentiator,
additionalSuffix);
return(string.Concat(
traceFileNamePrefix,
EtlConsumerConstants.FilteredEtwTraceFileExtension));
}
private static IDcaInMemoryConsumer CreateEtlToInMemoryBufferWriter(string logDirectory, bool?slow)
{
EventIndex globalLastEventIndexProcessed = default(EventIndex);
globalLastEventIndexProcessed.Set(DateTime.MinValue, -1);
InternalFileSink fileSink = new InternalFileSink(Utility.TraceSource, LogSourceId);
EventIndex lastEventIndexProcessed = default(EventIndex);
var onProcessingPeriodStartActionForFastWriter = new Action <string, bool, string>((traceFileName, isActiveEtl, traceFileSubFolder) =>
{
fileSink.Initialize();
lastEventIndexProcessed.Set(DateTime.MinValue, -1);
});
var maxIndexAlreadyProcessedForFastWriter = new Func <string, EventIndex>((traceFileSubFolder) =>
{
return(globalLastEventIndexProcessed);
});
var consumerProcessTraceEventActionForFastWriter = new Action <DecodedEventWrapper, string>((decodedEventWrapper, traceFileSubFolder) =>
{
string etwEvent = decodedEventWrapper.StringRepresentation.Replace("\r\n", "\r\t").Replace("\n", "\t");
fileSink.WriteEvent(etwEvent);
lastEventIndexProcessed.Set(decodedEventWrapper.Timestamp, decodedEventWrapper.TimestampDifferentiator);
});
var onProcessingPeriodStopActionForFastWriter = new Action <string, bool, string>((traceFileName, isActiveEtl, traceFileSubFolder) =>
{
if (slow.HasValue && slow.Value)
{
Thread.Sleep(2000);
}
fileSink.Close();
if (fileSink.WriteStatistics.EventsWritten > 0)
{
var additionalSuffix = (slow.HasValue) ? (slow.Value ? "_slow" : "_fast") : (string.Empty);
var destFileName = CreateDestinationFileName(traceFileName, additionalSuffix, isActiveEtl, lastEventIndexProcessed);
File.Move(fileSink.TempFileName, Path.Combine(logDirectory, "output", destFileName));
globalLastEventIndexProcessed.Set(lastEventIndexProcessed.Timestamp, lastEventIndexProcessed.TimestampDifferentiator);
}
else
{
fileSink.Delete();
}
});
var dcaInMemoryConsumer = TestUtility.MockRepository.Create <IDcaInMemoryConsumer>();
dcaInMemoryConsumer.Setup(c => c.ConsumerProcessTraceEventAction)
.Returns(consumerProcessTraceEventActionForFastWriter);
dcaInMemoryConsumer.Setup(c => c.MaxIndexAlreadyProcessed)
.Returns(maxIndexAlreadyProcessedForFastWriter);
dcaInMemoryConsumer.Setup(c => c.OnProcessingPeriodStart(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>()))
.Callback((string traceFileName, bool isActiveEtl, string traceFileSubFolder) => onProcessingPeriodStartActionForFastWriter(traceFileName, isActiveEtl, traceFileSubFolder));
dcaInMemoryConsumer.Setup(c => c.OnProcessingPeriodStop(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>()))
.Callback((string traceFileName, bool isActiveEtl, string traceFileSubFolder) => onProcessingPeriodStopActionForFastWriter(traceFileName, isActiveEtl, traceFileSubFolder));
return(dcaInMemoryConsumer.Object);
}
/// <summary>
/// Updates the bookmark file with the last event read index.
/// </summary>
/// <param name="bookmarkFolder"></param>
/// <param name="lastReadEventIndexPosition"></param>
/// <param name="eventIndex"></param>
/// <param name="bytesWritten"></param>
/// <returns></returns>
internal bool UpdateBookmarkFile(
string bookmarkFolder,
long lastReadEventIndexPosition,
EventIndex eventIndex,
out long bytesWritten)
{
bytesWritten = 0;
FileStream fs = null;
StreamWriter writer = null;
string bookmarkFile = Path.Combine(bookmarkFolder, BookmarkFileName);
if (false == FabricFile.Exists(bookmarkFile))
{
return(false);
}
try
{
// Open the bookmark file
try
{
Utility.PerformIOWithRetries(
() =>
{
fs = new FileStream(bookmarkFile, FileMode.Open);
writer = new StreamWriter(fs);
},
this.methodExecutionInitialRetryIntervalMs,
this.methodExecutionMaxRetryCount,
this.methodExecutionMaxRetryIntervalMs);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to open bookmark file {0} while processing events.",
bookmarkFile);
return(false);
}
// Move the stream position to the point where the event index needs to be written
fs.Position = lastReadEventIndexPosition;
long localBytesWritten = 0;
// Write the timestamp and index of the last event read and close the file
string lastEventReadString = string.Format("{0},{1},{2}", eventIndex.Timestamp.ToBinary(), eventIndex.Timestamp.ToString(), eventIndex.TimestampDifferentiator);
try
{
Utility.PerformIOWithRetries(
() =>
{
writer.WriteLine(lastEventReadString);
localBytesWritten = lastEventReadString.Length + 2;
writer.Dispose();
fs.Dispose();
},
this.methodExecutionInitialRetryIntervalMs,
this.methodExecutionMaxRetryCount,
this.methodExecutionMaxRetryIntervalMs);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to write last event read {0} in bookmark file {1} while processing events.",
lastEventReadString,
bookmarkFile);
return(false);
}
// record bytes written
bytesWritten = localBytesWritten;
}
finally
{
if (null != writer)
{
writer.Dispose();
}
if (null != fs)
{
fs.Dispose();
}
}
return(true);
}
public EventRepository(IElasticClient elasticClient, EventIndex index, IValidator <PersistentEvent> validator = null, IMessagePublisher messagePublisher = null)
: base(elasticClient, index, validator, null, messagePublisher)
{
EnableCache = false;
BatchNotifications = true;
}
/// <inheritdoc />
public virtual SummaryIndexBase[] ConvertEventsToSummaryIndices(IEnumerable <EventBase> events, TimeSpan unitTime, TimeSpan duration, double scoreThreshold)
{
if (duration == TimeSpan.Zero)
{
return(null);
}
double units = duration.TotalSeconds / unitTime.TotalSeconds;
// get whole minutes
int unitCount = (int)(units / 1);
// add fractional minute
if (units % 1 > 0.0)
{
unitCount += 1;
}
// to store event counts
var eventsPerUnitTime = new int[unitCount];
// to store counts of high scoring events
var bigEvsPerUnitTime = new int[unitCount];
foreach (var anEvent in events)
{
// note: absolute determines what value is used
// EventStartSeconds (relative to ~~segment~~, 2017-09: RELATIVE TO RECORDING)
// StartOffset (relative to recording)
double eventStart = anEvent.EventStartSeconds;
double eventScore = anEvent.Score;
var timeUnit = (int)(eventStart / unitTime.TotalSeconds);
// NOTE: eventScore filter replaced with greater then as opposed to not equal to
if (eventScore >= 0.0)
{
eventsPerUnitTime[timeUnit]++;
}
if (eventScore > scoreThreshold)
{
bigEvsPerUnitTime[timeUnit]++;
}
}
var indices = new SummaryIndexBase[eventsPerUnitTime.Length];
for (int i = 0; i < eventsPerUnitTime.Length; i++)
{
var newIndex = new EventIndex
{
ResultStartSeconds = unitTime.Multiply(i).TotalSeconds,
EventsTotal = eventsPerUnitTime[i],
EventsTotalThresholded = bigEvsPerUnitTime[i],
SegmentDurationSeconds = unitTime.TotalSeconds,
};
indices[i] = newIndex;
}
return(indices);
}
ShippingEvent GetShippingEvent(EventIndex eventIdx) => GetValueFromStorageMap <ShippingEvent>("ProductTracking", "AllEvents", eventIdx);
public EventID(uint eventType, uint eventId, uint eventTarget)
{
index = new EventIndex(eventType, eventId);
target = eventTarget;
}
/// <summary>
/// Retrieves the last event index processed.
/// </summary>
/// <param name="bookmarkFolder"></param>
/// <param name="bytesRead"></param>
/// <returns></returns>
internal EventIndex ReadBookmarkFile(
string bookmarkFolder,
out long bytesRead)
{
bytesRead = 0;
EventIndex lastEventIndex = new EventIndex();
lastEventIndex.Set(DateTime.MinValue, -1);
string bookmarkFile = Path.Combine(bookmarkFolder, BookmarkFileName);
if (false == FabricFile.Exists(bookmarkFile))
{
// Bookmark file doesn't exist
return(lastEventIndex);
}
StreamReader reader = null;
try
{
// Open the file
try
{
Utility.PerformIOWithRetries(
() =>
{
FileStream fileStream = FabricFile.Open(bookmarkFile, FileMode.Open, FileAccess.Read);
Helpers.SetIoPriorityHint(fileStream.SafeFileHandle, Kernel32Types.PRIORITY_HINT.IoPriorityHintVeryLow);
reader = new StreamReader(fileStream);
},
this.methodExecutionInitialRetryIntervalMs,
this.methodExecutionMaxRetryCount,
this.methodExecutionMaxRetryIntervalMs);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to open bookmark file {0}.",
bookmarkFile);
return(lastEventIndex);
}
long localBytesRead = 0;
// Get the version
string versionString = string.Empty;
try
{
Utility.PerformIOWithRetries(
() =>
{
versionString = reader.ReadLine();
localBytesRead += versionString.Length + 2;
},
this.methodExecutionInitialRetryIntervalMs,
this.methodExecutionMaxRetryCount,
this.methodExecutionMaxRetryIntervalMs);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to read version information from bookmark file {0}.",
bookmarkFile);
return(lastEventIndex);
}
// Check the version
if (false == versionString.Equals(BookmarkFileFormatVersionString, StringComparison.Ordinal))
{
this.traceSource.WriteError(
this.logSourceId,
"Unexpected version string {0} encountered in bookmark file {1}.",
versionString,
bookmarkFile);
return(lastEventIndex);
}
// Get information about the last event that we read
string infoLine = string.Empty;
try
{
Utility.PerformIOWithRetries(
() =>
{
infoLine = reader.ReadLine();
localBytesRead += infoLine.Length + 2;
},
this.methodExecutionInitialRetryIntervalMs,
this.methodExecutionMaxRetryCount,
this.methodExecutionMaxRetryIntervalMs);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to read information about last event read from bookmark file {0}.",
bookmarkFile);
return(lastEventIndex);
}
string[] infoLineParts = infoLine.Split(',');
if (infoLineParts.Length != (int)LastEventReadInfoParts.Count)
{
this.traceSource.WriteError(
this.logSourceId,
"The information in bookmark file {0} about the last event read is not in the expected format. {1}",
bookmarkFile,
infoLine);
return(lastEventIndex);
}
string lastEventTimestampString = infoLineParts[(int)LastEventReadInfoParts.LastEventTimestampLong].Trim();
long lastEventTimestampBinary;
if (false == long.TryParse(lastEventTimestampString, out lastEventTimestampBinary))
{
this.traceSource.WriteError(
this.logSourceId,
"Unable to retrieve timestamp of last event from bookmark file {0}.",
bookmarkFile);
return(lastEventIndex);
}
DateTime lastEventTimestamp = DateTime.FromBinary(lastEventTimestampBinary);
string lastEventTimestampDifferentiatorString = infoLineParts[(int)LastEventReadInfoParts.LastEventIndex].Trim();
int lastEventTimestampDifferentiator;
if (false == int.TryParse(lastEventTimestampDifferentiatorString, out lastEventTimestampDifferentiator))
{
this.traceSource.WriteError(
this.logSourceId,
"Unable to retrieve timestamp differentiator of last event from bookmark file {0}.",
bookmarkFile);
return(lastEventIndex);
}
// record bytes read
bytesRead = localBytesRead;
lastEventIndex.Set(lastEventTimestamp, lastEventTimestampDifferentiator);
}
finally
{
if (null != reader)
{
reader.Dispose();
}
}
return(lastEventIndex);
}
public EventID(EventIndex eventIndex, uint eventTarget)
{
index = eventIndex;
target = eventTarget;
}
public EventStats(IElasticClient elasticClient, EventIndex eventIndex)
{
_elasticClient = elasticClient;
_eventIndex = eventIndex;
}
public EventUID(EventIndex eventId, double time)
{
EventId = eventId;
Time = time;
}
