public static async Task <ClientAppUser> GetUserOrAddIfMissing(ITelemetryUnitOfWork work, TelemetryItem item, string ip)
{
ClientAppUser user = null;
if (!string.IsNullOrEmpty(item.AuthenticatedUserIdentifier))
{
user = await work.ClientAppUsers.FirstOrDefaultAsync(x => x.AuthenticatedUserIdentifier == item.AuthenticatedUserIdentifier).ConfigureAwait(false);
}
if (user == null)
{
user = await work.ClientAppUsers.FirstOrDefaultAsync(x => x.UserIdentifier == item.UserIdentifier).ConfigureAwait(false);
}
if (user == null)
{
user = new ClientAppUser();
user.UserIdentifier = item.UserIdentifier ?? "";
user.AuthenticatedUserIdentifier = item.AuthenticatedUserIdentifier;
user.FirstSeenDate = DateTime.UtcNow;
user.IpAddresses.Add(ip);
work.ClientAppUsers.Add(user);
}
else
{
if (!user.IpAddresses.Contains(ip))
{
user.IpAddresses.Add(ip);
}
}
return(user);
}
public static async Task <ITelemetryAware> GetViewOrAddIfMissing(ITelemetryUnitOfWork work, string viewName, TelemetryRootObject program)
{
View view = await work.Views.FirstOrDefaultAsync(x => x.Name == viewName && x.Program.ProgramId == program.ProgramId).ConfigureAwait(false);
if (view == null)
{
view = new View {
Name = viewName, Program = program, ProgramId = program.ProgramId
};
work.Views.Add(view);
}
return(view);
}
private static async Task <ITelemetryAware> GetTrackedComponent(ITelemetryUnitOfWork work, TelemetryItemTypes itemType, string key, TelemetryRootObject program)
{
switch (itemType)
{
case TelemetryItemTypes.Event:
return(await GetEventOrAddIfMissing(work, key, program).ConfigureAwait(false));
case TelemetryItemTypes.View:
return(await GetViewOrAddIfMissing(work, key, program).ConfigureAwait(false));
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
}
public static async Task <ITelemetryAware> GetEventOrAddIfMissing(ITelemetryUnitOfWork work, string componentName, TelemetryRootObject root)
{
Event obj = await work.Events.FirstOrDefaultAsync(x => x.Name == componentName && x.Program.ProgramId == root.ProgramId).ConfigureAwait(false);
if (obj == null)
{
obj = new Event()
{
Name = componentName, Program = root, ProgramId = root.ProgramId
};
work.Events.Add(obj);
}
return(obj);
}
private static void AddExceptions(ITelemetryUnitOfWork work, TelemetryRootObject program, IGrouping <TelemetryItemTypes, TelemetryItem> typeGrouping
, ClientAppUser clientAppUser)
{
foreach (TelemetryItem telemetryItem in typeGrouping)
{
foreach (TelemetryItem.ExceptionInfo telemetryItemException in telemetryItem.Exceptions)
{
var exception = new ExceptionInfo
{
Timestamp = telemetryItem.Timestamp
, ProgramId = program.ProgramId
, ProgramVersion = telemetryItem.VersionData.FileVersion
, UserName = clientAppUser.UserIdentifier
, Sequence = telemetryItem.Sequence
, ExceptionId = telemetryItemException.Id
, ExceptionOuterId = telemetryItemException.OuterId
, HasFullStack = telemetryItemException.HasFullStack
, Message = telemetryItemException.Message
, Note = GetExceptionNote(telemetryItem.Properties)
, TypeName = telemetryItemException.TypeName
, ParsedStack = JsonConvert.SerializeObject(telemetryItemException.ParsedStack)
};
if (telemetryItem.Properties != null && telemetryItem.Properties.Any())
{
foreach (KeyValuePair <string, string> unit in telemetryItem.Properties)
{
ExceptionTelemetryUnit telemetryUnit = new ExceptionTelemetryUnit {
Key = unit.Key, ValueString = unit.Value?.ToString(), UnitType = TelemetryUnit.UnitTypes.Property
};
((List <ExceptionTelemetryUnit>)exception.TelemetryUnits).Add(telemetryUnit);
}
}
if (telemetryItem.Measurements != null && telemetryItem.Measurements.Any())
{
foreach (KeyValuePair <string, double> unit in telemetryItem.Measurements)
{
ExceptionTelemetryUnit telemetryUnit = new ExceptionTelemetryUnit {
Key = unit.Key, ValueDouble = unit.Value, UnitType = TelemetryUnit.UnitTypes.Metric
};
((List <ExceptionTelemetryUnit>)exception.TelemetryUnits).Add(telemetryUnit);
}
}
work.Exceptions.Add(exception);
}
}
}
private static void AddLogs(ITelemetryUnitOfWork work, TelemetryRootObject program, IGrouping <TelemetryItemTypes, TelemetryItem> typeGrouping)
{
foreach (TelemetryItem telemetryItem in typeGrouping)
{
var logMsg = new LogMessage()
{
Timestamp = telemetryItem.Timestamp
, Id = Guid.NewGuid()
, UserName = telemetryItem.UserIdentifier
, Sequence = telemetryItem.Sequence
, Message = telemetryItem.LogMessage
, ProgramId = program.ProgramId
, Level = telemetryItem.LogLevel
};
work.LogMessages.Add(logMsg);
}
}
private static async Task AddTelemetries(ITelemetryUnitOfWork work, TelemetryRootObject program, string ipAddress
, IGrouping <TelemetryItemTypes, TelemetryItem> typeGrouping, ClientAppUser clientAppUser, List <TelemetrySummary> summaries)
{
foreach (IGrouping <string, TelemetryItem> keyGroupings in typeGrouping.GroupBy(x => x.EntryKey))
{
ITelemetryAware trackedComponent = await GetTrackedComponent(work, typeGrouping.Key, keyGroupings.Key, program)
.ConfigureAwait(false);
TelemetrySummary summary = GetTelemetrySummary(clientAppUser, trackedComponent);
foreach (TelemetryItem telemetryItem in keyGroupings)
{
summary.UpdateTelemetry(keyGroupings.First().VersionData, ipAddress, telemetryItem);
}
summaries.Add(summary);
}
}
public static async Task <ClientAppUser> GetUserOrAddIfMissing(ITelemetryUnitOfWork work, UserInfo userDto, string ip)
{
ClientAppUser user = await work.ClientAppUsers.FirstOrDefaultAsync(x => x.UserIdentifier == userDto.UserIdentifier).ConfigureAwait(false);
if (user == null)
{
user = Mapper.Map <ClientAppUser>(userDto);
user.FirstSeenDate = DateTime.UtcNow;
user.IpAddresses.Add(ip);
work.ClientAppUsers.Add(user);
}
else
{
if (!user.IpAddresses.Contains(ip))
{
user.IpAddresses.Add(ip);
}
}
return(user);
}
/// <summary>
/// New instance
/// </summary>
/// <param name="work"></param>
public TelemetryController(ITelemetryUnitOfWork work)
{
this.work = work;
}
/// <summary>
/// New instance
/// </summary>
/// <param name="work"></param>
/// <param name="telemetryClient"></param>
public TelemetryController(ITelemetryUnitOfWork work)
{
this.work = work;
this.telemetryClient = new TelemetryClient();
}
