public static async Task <List <TelemetrySummary> > InsertData(ITelemetryUnitOfWork work, List <TelemetryItem> units, TelemetryRootObject program, string ipAddress)
{
if (units.Any())
{
ClientAppUser clientAppUser =
await GetUserOrAddIfMissing(work, units.First(), ipAddress).ConfigureAwait(false);
IEnumerable <IGrouping <TelemetryItemTypes, TelemetryItem> > typeGroupings =
units.GroupBy(x => x.TelemetryItemType);
List <TelemetrySummary> summaries = new List <TelemetrySummary>();
foreach (IGrouping <TelemetryItemTypes, TelemetryItem> typeGrouping in typeGroupings)
{
if (typeGrouping.Key == TelemetryItemTypes.Exception)
{
AddExceptions(work, program, typeGrouping, clientAppUser);
}
else if (typeGrouping.Key == TelemetryItemTypes.LogMessage)
{
AddLogs(work, program, typeGrouping);
}
else
{
await AddTelemetries(work, program, ipAddress, typeGrouping, clientAppUser, summaries).ConfigureAwait(false);
}
}
await work.CompleteAsync().ConfigureAwait(false);
return(summaries);
}
return(null);
}
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 async Task AddUserInfo(ClientAppUser objectToAdd)
{
objectToAdd.RegisteredDate = DateTime.UtcNow;
this.DbContext.AppUsers.Add(objectToAdd);
await this.DbContext.SaveChangesAsync();
}
public static TelemetrySummary GetTelemetrySummary(ClientAppUser clientAppUser, ITelemetryAware component)
{
TelemetrySummary summary = component.GetTelemetrySummary(clientAppUser.Id);
if (summary == null)
{
summary = component.AddTelemetrySummary(clientAppUser.Id);
}
return(summary);
}
public async Task <TelemetryInitializeResponse> Initialize(TelemetryInitializeRequest request)
{
try
{
Stopwatch sw = Stopwatch.StartNew();
if (!ApiRequestsValidator.IsRequestValid(request))
{
return(new TelemetryInitializeResponse()
{
Exception = new BadRequestException("Request is not valid")
});
}
TelemetryRootObject program = await work.GetMonitoredProgram(request.TelemetryKey).ConfigureAwait(false);
if (program == null)
{
{
return(new TelemetryInitializeResponse {
Exception = new InvalidOperationException($"Program [{request.TelemetryKey}] is null")
});
}
}
string ip = "0.0.0.0";
ClientAppUser clientAppUser = await TelemetryControllerHelpers.GetUserOrAddIfMissing(this.work, request.UserInfo, ip).ConfigureAwait(false);
await this.work.CompleteAsync().ConfigureAwait(false);
TelemetryInitializeResponse response = new TelemetryInitializeResponse {
UserId = clientAppUser.PublicId
};
sw.Stop();
this.telemetryClient.TrackEvent("Initialize", new Dictionary <string, string>()
{
{ $"ProgramName", request.ProgramInfo?.Name },
{ $"ExecutionTime", sw.ElapsedMilliseconds.ToString() },
{ $"ProgramId", program.ProgramId.ToString() },
{ $"TelemetryKey", program.TelemetryKey.ToString() },
});
return(response);
}
catch (Exception ex)
{
return(new TelemetryInitializeResponse {
Exception = new InvalidOperationException("Error while processing telemetry initialize request", ex)
});
}
}
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);
}
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ClientAppUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
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);
}
public async Task <TelemetryInitializeResponse> Initialize(TelemetryInitializeRequest request)
{
try
{
if (!ApiRequestsValidator.IsRequestValid(request))
{
return(new TelemetryInitializeResponse()
{
Exception = new BadRequestException("Request is not valid")
});
}
TelemetryRootObject program = await work.GetMonitoredProgram(request.TelemetryKey).ConfigureAwait(false);
if (program == null)
{
{
return(new TelemetryInitializeResponse {
Exception = new InvalidOperationException($"Program [{request.TelemetryKey}] is null")
});
}
}
string ip = this.Request.GetClientIp();
ClientAppUser clientAppUser = await TelemetryControllerHelpers.GetUserOrAddIfMissing(this.work, request.UserInfo, ip).ConfigureAwait(false);
await this.work.CompleteAsync().ConfigureAwait(false);
TelemetryInitializeResponse response = new TelemetryInitializeResponse {
UserId = clientAppUser.PublicId
};
return(response);
}
catch (Exception ex)
{
return(new TelemetryInitializeResponse {
Exception = new InvalidOperationException("Error while processing telemetry initialize request", ex)
});
}
}
public async Task TestEventsVariousUsers()
{
TelemetryUnitOfWork unit = new TelemetryUnitOfWork(this.TelemetryContext, this.PortalContext, new AssemblyStreamVersionReader());
List <KeyValuePair <string, Guid> > apps = await Helpers.SeedInitialPrograms(this.PortalContext, this.TelemetryContext, 2, "TestApp", new[] { "Billy Jean", "Jack Black" });
Helpers.GetProgramAndUser(unit, "TestApp", "Billy Jean", out TelemetryRootObject prg, out ClientAppUser usr);
TelemetryItem telemetryItem = new TelemetryItem()
{
EntryKey = Helpers.GetName("Func1"),
TelemetryItemType = TelemetryItemTypes.Event,
Sequence = "aaa:1",
VersionData = new VersionData("1.2.3.4", "2.0.0.0"),
Timestamp = new DateTimeOffset(DateTime.UtcNow),
Properties = new Dictionary <string, string> {
{ "AKey", "AValue" }, { "AKey2", "AValue2" }
},
UserIdentifier = usr.UserIdentifier
};
List <TelemetrySummary> result = await TelemetryControllerHelpers.InsertData(unit, (new[] { telemetryItem }).ToList(), prg, "127.1.1.1");
Event @event = prg.Events.Single();
Guid eventId = this.TelemetryContext.Events.FirstOrDefault(x => x.Name == @event.Name).Id;
Helpers.AssertUpdateResponse(result, prg, usr, 1, Helpers.GetName("Func1"), eventId);
Assert.AreEqual(1, prg.Events.Count);
Assert.AreEqual(Helpers.GetName("Func1"), @event.Name);
Assert.AreEqual(1, @event.TelemetrySummaries.Count);
Assert.AreEqual(prg.ProgramId, @event.ProgramId);
TelemetrySummary summary = @event.GetTelemetrySummary(this.GetUserByGuid(result.First().ClientAppUser.Id).Id);
Assert.AreEqual(usr.Id, summary.ClientAppUserId);
TelemetryDetail detail = @event.GetTelemetryDetails(this.GetUserByGuid(result.First().ClientAppUser.Id).Id).Single();
Assert.AreEqual(detail.GetTelemetrySummary().Id, summary.Id);
Assert.AreEqual(usr.Id, detail.GetTelemetrySummary().ClientAppUserId);
Assert.AreEqual(usr.UserIdentifier, detail.UserIdentifier);
Assert.AreEqual(2, detail.GetTelemetryUnits().Count());
Assert.AreEqual("AKey", detail.GetTelemetryUnits().ElementAt(0).Key);
Assert.AreEqual("AValue", detail.GetTelemetryUnits().ElementAt(0).ValueString);
Assert.AreEqual("AKey2", detail.GetTelemetryUnits().ElementAt(1).Key);
Assert.AreEqual("AValue2", detail.GetTelemetryUnits().ElementAt(1).ValueString);
ClientAppUser otherUser = Helpers.GetUser(unit, "Jack Black");
telemetryItem = new TelemetryItem()
{
EntryKey = Helpers.GetName("Func1"),
TelemetryItemType = TelemetryItemTypes.Event,
Sequence = "aaa:1",
VersionData = new VersionData("1.2.3.4", "2.0.0.0"),
Timestamp = new DateTimeOffset(DateTime.UtcNow),
Properties = new Dictionary <string, string> {
{ "AKey3", "AValue3" }, { "AKey4", "AValue4" }, { "AKey5", "AValue5" }
},
UserIdentifier = otherUser.UserIdentifier
};
result = await TelemetryControllerHelpers.InsertData(unit, (new[] { telemetryItem }).ToList(), prg, "127.1.1.1");
Helpers.AssertUpdateResponse(result, prg, otherUser, 1, Helpers.GetName("Func1"), eventId);
prg = await unit.GetMonitoredProgram(prg.TelemetryKey);
Assert.AreEqual(1, prg.Events.Count);
@event = prg.Events.Single();
Assert.AreEqual(Helpers.GetName("Func1"), @event.Name);
Assert.AreEqual(2, @event.TelemetrySummaries.Count);
Assert.AreEqual(1, @event.GetTelemetrySummary(this.GetUserByGuid(result.First().ClientAppUser.Id).Id).SummaryCount);
Assert.AreEqual(1, summary.GetTelemetryDetails().Count());
Assert.AreNotEqual(otherUser.Id, usr.Id);
TelemetrySummary otherSummary = @event.GetTelemetrySummary(this.GetUserByGuid(result.First().ClientAppUser.Id).Id);
Assert.AreEqual(otherUser.Id, otherSummary.ClientAppUserId);
TelemetryDetail otherUserDetail = @event.GetTelemetryDetails(this.GetUserByGuid(result.First().ClientAppUser.Id).Id).Single();
Assert.AreEqual(otherUser.Id, otherUserDetail.GetTelemetrySummary().ClientAppUserId);
Assert.AreEqual(otherUser.UserIdentifier, otherUserDetail.UserIdentifier);
Assert.AreEqual(3, otherUserDetail.GetTelemetryUnits().Count());
Assert.AreEqual("AKey3", otherUserDetail.GetTelemetryUnits().ElementAt(0).Key);
Assert.AreEqual("AValue3", otherUserDetail.GetTelemetryUnits().ElementAt(0).ValueString);
Assert.AreEqual("AKey5", otherUserDetail.GetTelemetryUnits().ElementAt(2).Key);
Assert.AreEqual("AValue5", otherUserDetail.GetTelemetryUnits().ElementAt(2).ValueString);
telemetryItem = new TelemetryItem()
{
EntryKey = Helpers.GetName("Func1"),
TelemetryItemType = TelemetryItemTypes.Event,
Sequence = "aaa:1",
VersionData = new VersionData("1.2.3.4", "2.0.0.0"),
Timestamp = new DateTimeOffset(DateTime.UtcNow),
Properties = new Dictionary <string, string> {
{ "AKey", "AValue" }, { "AKey2", "AValue2" }
},
UserIdentifier = usr.UserIdentifier
};
//run again with first user
result = await TelemetryControllerHelpers.InsertData(unit, (new[] { telemetryItem }).ToList(), prg, "127.1.1.1");
@event = prg.Events.Single();
Assert.AreEqual(2, @event.TelemetrySummaries.Count);
Assert.AreEqual(2, @event.GetTelemetrySummary(this.GetUserByGuid(result.First().ClientAppUser.Id).Id).SummaryCount);
Assert.AreEqual(2, summary.GetTelemetryDetails().Count());
List <EventTelemetryDetail> details = @event.GetTelemetryDetails(this.GetUserByGuid(result.First().ClientAppUser.Id).Id).OrderBy(x => x.Timestamp)
.Cast <EventTelemetryDetail>().ToList();
Assert.AreEqual(2, details.Count);
Assert.IsTrue(details.All(x => x.TelemetrySummary.ClientAppUserId == this.GetUserByGuid(result.First().ClientAppUser.Id).Id));
Assert.IsTrue(details.First().Timestamp < details.Last().Timestamp);
Assert.AreEqual(3, this.TelemetryContext.EventTelemetryDetails.Count(x => x.TelemetrySummary.Event.Name == telemetryItem.EntryKey));
Assert.AreEqual(2, this.TelemetryContext.EventTelemetryDetails.Count(x => x.TelemetrySummaryId == summary.Id));
}
public static void AssertUpdateResponse(List <TelemetrySummary> response, TelemetryRootObject prg, ClientAppUser usr,
int expectedSummariesCount, string funcName = null, Guid funcId = default(Guid))
{
Assert.AreEqual(expectedSummariesCount, response.Count);
Assert.AreEqual(1, response.Count(x => x.GetComponent().Name == funcName));
if (funcId != Guid.Empty)
{
Assert.AreEqual(1, response.Count(x => x.GetComponent().Id == funcId));
}
Assert.IsTrue(response.All(x => x.GetComponent().Program.TelemetryKey == prg.TelemetryKey));
Assert.IsTrue(response.All(x => x.ClientAppUser.Id == usr.Id));
}
public static void GetProgramAndUser(TelemetryUnitOfWork unit, string programName, string userName, out TelemetryRootObject prg, out ClientAppUser usr
, [CallerMemberName] string methodIdentifier = "")
{
string prgName = GetName(programName, methodIdentifier);
var p = unit.Programs.GetByNames("SeedInitialProgramsSomeDeveloper", prgName).GetAwaiter().GetResult();
prg = unit.GetMonitoredProgram(p.TelemetryKey).Result;
usr = GetUser(unit, userName, methodIdentifier);
}
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 ViewTelemetrySummary GetUsage(View view, ClientAppUser clientAppUser)
{
return(this.TelimenaPortalContext.ViewTelemetrySummaries.FirstOrDefault(x => x.View.Id == view.Id && x.ClientAppUserId == clientAppUser.Id));
}
public static void GetProgramAndUser(TelemetryUnitOfWork unit, string programName, string userName, out TelemetryRootObject prg, out ClientAppUser usr
, [CallerMemberName] string methodIdentifier = "")
{
string prgName = GetName(programName, methodIdentifier);
var p = unit.GetProgramFirstOrDefault(x => x.Name == prgName).GetAwaiter().GetResult();
prg = unit.GetMonitoredProgram(p.TelemetryKey).Result;
usr = GetUser(unit, userName, methodIdentifier);
}
