private JObject BuildLocator(InstrumentationEvent instrumentationEvent)
{
var locator = new JObject();
try
{
var senderId = instrumentationEvent.SenderId;
var senderParentId = instrumentationEvent.SenderParentId;
if (string.IsNullOrWhiteSpace(senderId) || string.IsNullOrWhiteSpace(senderParentId))
{
return(null);
}
locator.Add(TARGET_KEY, senderId);
locator.Add(SCOPE_KEY, senderParentId);
var senderContext = instrumentationEvent.SenderContext;
if (senderContext != null)
{
locator.Add(CONTEXT_KEY, senderContext);
}
}
catch (Exception ex)
{
throw new Exception("Exception thrown while transforming JSON", ex);
}
return(locator);
}
/// <summary>
/// Publishes an event to all registered network endpoints after
/// applying the required event format transforms. Stored event will be
/// deleted if publishing was successful for all registered endpoints.
/// This method should NOT be called from the main thread
/// </summary>
/// <param name="instrumentationEvent"></param>
/// <returns></returns>
public async Task PublishEvent(InstrumentationEvent instrumentationEvent)
{
if (instrumentationEvent == null)
{
return;
}
var events = new List <InstrumentationEvent>();
events.Add(instrumentationEvent);
await PublishEventsAsync(events);
}
public async Task TestStoreOneEvent()
{
await EventStoreManager.DeleteAllEventsAsync().ConfigureAwait(false);
InstrumentationEvent instrumentationEvent = createTestEvent();
Assert.IsNotNull(instrumentationEvent, "Generated event stored should not be null");
await EventStoreManager.StoreEventAsync(instrumentationEvent).ConfigureAwait(false);
var events = await EventStoreManager.FetchAllEventsAsync();
Assert.IsNotNull(events, "List of events stored should not be null");
Assert.AreEqual(1, events.Count, "Number of events stored should be 1");
Assert.IsTrue(instrumentationEvent.Equals(events.ElementAt(0)), "Stored event should be the same as generated event");
}
public async Task TestFetchOneEvent()
{
await EventStoreManager.DeleteAllEventsAsync().ConfigureAwait(false);
InstrumentationEvent instrumentationEvent = createTestEvent();
Assert.IsNotNull(instrumentationEvent, "Generated event stored should not be null");
await EventStoreManager.StoreEventAsync(instrumentationEvent).ConfigureAwait(false);
var eventId = instrumentationEvent.EventId;
var fetchedEvent = await EventStoreManager.FetchEventAsync(eventId);
Assert.IsNotNull(fetchedEvent, "Event stored should not be null");
Assert.IsTrue(instrumentationEvent.Equals(fetchedEvent), "Stored event should be the same as generated event");
}
public async Task StoreEventAsync(InstrumentationEvent instrumentationEvent)
{
if (string.IsNullOrEmpty(instrumentationEvent?.ToJson().ToString()))
{
LoggingService.Log("Invalid Event", LoggingLevel.Error);
return;
}
if (await ShouldStoreEventAsync().ConfigureAwait(false))
{
var fileName = instrumentationEvent.EventId + FilenameSuffix;
//Open file
IFile file = await _rootDir.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
//Wrtie to file after encrypting contents
await file.WriteAllTextAsync(Encrypt(instrumentationEvent.ToJson().ToString(), EncryptionKey)).ConfigureAwait(false);
}
}
private JObject BuildDeviceAttributes(InstrumentationEvent instrumentationEvent)
{
var deviceAttributes = new JObject();
try
{
var deviceAppAttributes = instrumentationEvent.DeviceAppAttributes;
if (deviceAppAttributes != null)
{
deviceAttributes = deviceAppAttributes.ToJson();
}
deviceAttributes.Add(CONNECTION_TYPE_KEY, instrumentationEvent.ConnectionType);
}
catch (Exception ex)
{
throw new Exception("Exception thrown while transforming JSON", ex);
}
return(deviceAttributes);
}
public JObject Transform(InstrumentationEvent instrumentationEvent)
{
if (instrumentationEvent == null)
{
return(null);
}
JObject logLine = BuildPayload(instrumentationEvent);
try
{
logLine?.Add(DEVICE_ATTRIBUTES_KEY, BuildDeviceAttributes(instrumentationEvent));
}
catch (Exception ex)
{
throw new Exception("Exception thrown while transforming JSON", ex);
}
return(logLine);
}
public async Task TestSotreMultipleEvents()
{
await EventStoreManager.DeleteAllEventsAsync().ConfigureAwait(false);
InstrumentationEvent instrumentationEvent1 = createTestEvent();
Assert.IsNotNull(instrumentationEvent1, "Generated event stored should not be null");
InstrumentationEvent instrumentationEvent2 = createTestEvent();
Assert.IsNotNull(instrumentationEvent2, "Generated event stored should not be null");
var generatedEvents = new List <InstrumentationEvent>();
generatedEvents.Add(instrumentationEvent1);
generatedEvents.Add(instrumentationEvent2);
await EventStoreManager.StoreEventsAsync(generatedEvents);
var storedEvents = await EventStoreManager.FetchAllEventsAsync();
Assert.IsNotNull(storedEvents, "List of events stored should not be null");
Assert.AreEqual(2, storedEvents.Count, "Number of events stored should be 2");
Assert.IsTrue(storedEvents.Contains(instrumentationEvent1), "Stored event should be the same as generated event");
Assert.IsTrue(storedEvents.Contains(instrumentationEvent2), "Stored event should be the same as generated event");
}
private JObject BuildPayload(InstrumentationEvent instrumentationEvent)
{
var payload = new JObject();
try
{
payload.Add(VERSION_KEY, VERSION_VALUE);
var schemaType = instrumentationEvent.Schema;
payload.Add(SCHEMA_TYPE_KEY, schemaType.ToString());
payload.Add(ID_KEY, instrumentationEvent.EventId);
payload.Add(EVENT_SOURCE_KEY, instrumentationEvent.Name);
payload.Add(TS_KEY, instrumentationEvent.StartTime);
payload.Add(PAGE_START_TIME_KEY, instrumentationEvent.SessionStartTime);
var duration = instrumentationEvent.EndTime - instrumentationEvent.StartTime;
if (duration > 0)
{
if (schemaType == InstrumentationEvent.SchemaType.LightningInteraction ||
schemaType == InstrumentationEvent.SchemaType.LightningPerformance)
{
payload.Add(DURATION_KEY, duration);
}
else if (schemaType == InstrumentationEvent.SchemaType.LightningPageView)
{
payload.Add(EPT_KEY, duration);
}
}
if (!string.IsNullOrWhiteSpace(instrumentationEvent.SessionId))
{
payload.Add(CLIENT_SESSION_ID_KEY, instrumentationEvent.SessionId);
}
if (schemaType != InstrumentationEvent.SchemaType.LightningPerformance)
{
payload.Add(SEQUENCE_KEY, instrumentationEvent.SequenceId);
}
if (instrumentationEvent.Attributes != null)
{
payload.Add(ATTRIBUTES_KEY, instrumentationEvent.Attributes);
}
if (schemaType != InstrumentationEvent.SchemaType.LightningPerformance &&
instrumentationEvent.Page != null)
{
payload.Add(PAGE_KEY, instrumentationEvent.Page);
}
if (instrumentationEvent.PreviousPage != null &&
schemaType == InstrumentationEvent.SchemaType.LightningPageView)
{
payload.Add(PREVIOUS_PAGE_KEY, instrumentationEvent.PreviousPage);
}
if (instrumentationEvent.Marks != null &&
schemaType == InstrumentationEvent.SchemaType.LightningPageView)
{
payload.Add(MARKS_KEY, instrumentationEvent.Marks);
}
if (schemaType == InstrumentationEvent.SchemaType.LightningInteraction ||
schemaType == InstrumentationEvent.SchemaType.LightningPageView)
{
var locator = BuildLocator(instrumentationEvent);
if (locator != null)
{
payload.Add(LOCATOR_KEY, locator);
}
}
var eventType = instrumentationEvent.Event;
string eventTypeString = null;
if (schemaType == InstrumentationEvent.SchemaType.LightningPerformance)
{
eventTypeString = PERF_EVENT_TYPE;
}
else if (schemaType == InstrumentationEvent.SchemaType.LightningInteraction)
{
eventTypeString = eventType.ToString();
}
if (!string.IsNullOrWhiteSpace(eventTypeString))
{
payload.Add(EVENT_TYPE_KEY, eventTypeString);
}
var errorType = instrumentationEvent.Error;
if (schemaType == InstrumentationEvent.SchemaType.LightningError)
{
payload.Add(ERROR_TYPE_KEY, errorType.ToString());
}
}
catch (Exception ex)
{
throw new Exception("Exception thrown while transforming JSON", ex);
}
return(payload);
}
/// <summary>
/// Store information in a Database
/// </summary>
/// <param name="flushInfo">The buffered Event Information</param>
private void StoreToDB(WebBaseEvent flushInfo)
{
InstrumentationEvent evt = (flushInfo as InstrumentationEvent);
}
/// <summary>
///
/// </summary>
///
private void FireEntitySavedEvent()
{
InstrumentationEvent instrumentationEvent = new InstrumentationEvent();
instrumentationEvent.Message = "Entity entity-1 has been saved.";
instrumentationEvent.Id = 100;
instrumentationEvent.Fire();
}
public void TestFireInstrumentationEvent()
{
for (int i = 0; i < 10; i++)
{
InstrumentationEvent instrumentationEvent = new InstrumentationEvent();
instrumentationEvent.Message = string.Format("Entity entity-{0} has been saved.", i);
instrumentationEvent.Id = (i * 100);
instrumentationEvent.Fire();
}
}
