public async Task <IHttpActionResult> Post(Guid telemetryKey)
{
try
{
TelemetryRootObject program = await this.work.GetMonitoredProgram(telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new BadRequestException($"Program with telemetry key [{telemetryKey}] does not exist");
}
IEnumerable <AppInsightsTelemetry> appInsightsTelemetries = AppInsightsDeserializer.Deserialize(await this.Request.Content.ReadAsByteArrayAsync().ConfigureAwait(false), true);
List <TelemetryItem> telemetryItems = TelemetryMapper.Map(appInsightsTelemetries).ToList();
string ip = "0.0.0.0";
await this.InsertDataInternal(telemetryItems, program, ip).ConfigureAwait(false);
return(await Task.FromResult(this.StatusCode(HttpStatusCode.Accepted)).ConfigureAwait(false));
}
catch (Exception e)
{
this.telemetryClient.TrackException(e, new Dictionary <string, string>()
{
{ $"Method", Routes.Post },
{ $"TelemetryKey", telemetryKey.ToString() }
});
throw;
}
}
private async Task RegisterProgramInternal(DeveloperTeam developerTeam, Program program, ProgramAssembly primaryAss)
{
using (var dbContextTransaction = this.portalContext.Database.BeginTransaction())
{
try
{
developerTeam.AddProgram(program);
program.PrimaryAssembly = primaryAss;
this.portalContext.Programs.Add(program);
await this.portalContext.SaveChangesAsync().ConfigureAwait(false);
var savedPrg = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.PublicId == program.PublicId).ConfigureAwait(false);
var teleRoot = new TelemetryRootObject()
{
ProgramId = savedPrg.Id,
TelemetryKey = savedPrg.TelemetryKey
};
this.telemetryContext.TelemetryRootObjects.Add(teleRoot);
await this.telemetryContext.SaveChangesAsync().ConfigureAwait(false);
dbContextTransaction.Commit();
}
catch (Exception)
{
dbContextTransaction.Rollback();
throw;
}
}
}
public async Task <IHttpActionResult> PostBasic(Guid telemetryKey, BasicTelemetryItem request)
{
if (request == null)
{
request = new BasicTelemetryItem();
}
TelemetryRootObject program = await this.work.GetMonitoredProgram(telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new BadRequestException($"Program with telemetry key [{telemetryKey}] does not exist");
}
try
{
TelemetryItem item = TelemetryMapper.Map(telemetryKey, request);
string ip = this.Request.GetClientIp();
await this.InsertDataInternal(new[] { item }, program, ip).ConfigureAwait(false);
return(await Task.FromResult(this.StatusCode(HttpStatusCode.OK)).ConfigureAwait(false));
}
catch (Exception ex)
{
return(await Task.FromResult(this.InternalServerError(new InvalidOperationException($"Error while inserting entry: {ex}"))).ConfigureAwait(false));
}
}
private async Task RegisterProgramInternalFallback(DeveloperTeam developerTeam, Program program, ProgramAssembly primaryAss)
{
using (DbContextTransaction dbContextTransaction = this.portalContext.Database.BeginTransaction())
{
List <DbEntityEntry> changedEntities = this.portalContext.ChangeTracker.Entries().ToList();
changedEntities.AddRange(this.telemetryContext.ChangeTracker.Entries().ToList());
foreach (DbEntityEntry dbEntityEntry in changedEntities)
{
if (dbEntityEntry.State == EntityState.Added)
{
dbEntityEntry.State = EntityState.Detached;
}
else
{
await dbEntityEntry.ReloadAsync().ConfigureAwait(false);
}
}
int topPrgId = this.telemetryContext.TelemetryRootObjects.OrderByDescending(x => x.ProgramId)
.FirstOrDefault()?.ProgramId ?? 0;
topPrgId++;
program.Id = topPrgId;
try
{
developerTeam.AddProgram(program);
string tblName = nameof(Program) + "s";
program.PrimaryAssembly = primaryAss;
this.portalContext.Database.ExecuteSqlCommand($"DBCC CHECKIDENT('[dbo].[{tblName}]', RESEED, {topPrgId})");
this.portalContext.Programs.Add(program);
await this.portalContext.SaveChangesAsync().ConfigureAwait(false);
Program savedPrg = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.PublicId == program.PublicId).ConfigureAwait(false);
TelemetryRootObject teleRoot = new TelemetryRootObject()
{
ProgramId = savedPrg.Id,
TelemetryKey = savedPrg.TelemetryKey
};
this.telemetryContext.TelemetryRootObjects.Add(teleRoot);
await this.telemetryContext.SaveChangesAsync().ConfigureAwait(false);
dbContextTransaction.Commit();
}
catch (Exception)
{
dbContextTransaction.Rollback();
throw;
}
}
}
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 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)
});
}
}
/// <summary>
/// Creates the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="program">The program.</param>
/// <returns>TelemetryQueryResponse.</returns>
public static TelemetryQueryResponse Create(TelemetryQueryRequest request, TelemetryRootObject program)
{
TelemetryQueryResponse queryResult = new TelemetryQueryResponse();
IEnumerable <IEnumerable <ITelemetryAware> > collections = GetCollections(request.TelemetryItemTypes, program);
foreach (IEnumerable <ITelemetryAware> collection in collections)
{
foreach (ITelemetryAware telemetryAwareComponent in collection.Where(cmp => request.ComponentKeys.Contains("*") || request.ComponentKeys.Contains(cmp.Name)))
{
ProcessComponents(request, queryResult, telemetryAwareComponent);
}
}
return(queryResult);
}
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 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);
}
}
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 async Task <List <TelemetryRootObject> > GetTelemetryRootObjects(List <Program> programs)
{
List <TelemetryRootObject> telemetryRootObjects = new List <TelemetryRootObject>();
foreach (Program program in programs)
{
TelemetryRootObject telePrg = await this.telemetryContext.TelemetryRootObjects
.FirstOrDefaultAsync(x => x.ProgramId == program.Id).ConfigureAwait(false);
if (telePrg != null)
{
telemetryRootObjects.Add(telePrg);
}
}
return(telemetryRootObjects);
}
public async Task <IHttpActionResult> ExecuteQuery(TelemetryQueryRequest request)
{
if (request.TelemetryKey == Guid.Empty)
{
return(this.BadRequest("Empty telemetry key"));
}
TelemetryRootObject prg = await this.work.GetMonitoredProgram(request.TelemetryKey).ConfigureAwait(false);
if (prg == null)
{
return(this.BadRequest($"Program with key [{request.TelemetryKey}] not found"));
}
TelemetryQueryResponse queryResult = TelemetryQueryResponseCreator.Create(request, prg);
return(this.Ok(queryResult));
}
public async Task <IHttpActionResult> Post(Guid telemetryKey)
{
TelemetryRootObject program = await this.work.GetMonitoredProgram(telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new BadRequestException($"Program with telemetry key [{telemetryKey}] does not exist");
}
IEnumerable <AppInsightsTelemetry> appInsightsTelemetries = AppInsightsDeserializer.Deserialize(await this.Request.Content.ReadAsByteArrayAsync().ConfigureAwait(false), true);
IEnumerable <TelemetryItem> telemetryItems = TelemetryMapper.Map(appInsightsTelemetries);
string ip = this.Request.GetClientIp();
await this.InsertDataInternal(telemetryItems, program, ip).ConfigureAwait(false);
return(await Task.FromResult(this.StatusCode(HttpStatusCode.Accepted)).ConfigureAwait(false));
}
public async Task <IHttpActionResult> PostV2()
{
IEnumerable <AppInsightsTelemetry> appInsightsTelemetries = AppInsightsDeserializer.Deserialize(await this.Request.Content.ReadAsByteArrayAsync().ConfigureAwait(false), true);
IEnumerable <TelemetryItem> telemetryItems = AppInsightsTelemetryMapper.Map(appInsightsTelemetries);
string ip = this.Request.GetClientIp();
//items might come with various telemetry key in one request (when there are multiple instances of telemetry client)
IEnumerable <IGrouping <Guid, TelemetryItem> > groups = telemetryItems.GroupBy(telemetry => telemetry.TelemetryKey);
foreach (IGrouping <Guid, TelemetryItem> grouping in groups)
{
TelemetryRootObject program = await this.work.GetMonitoredProgram(grouping.Key).ConfigureAwait(false);
await this.InsertDataInternal(grouping, program, ip).ConfigureAwait(false);
}
return(await Task.FromResult(this.StatusCode(HttpStatusCode.Accepted)).ConfigureAwait(false));
}
public async Task <IHttpActionResult> PostWithVariousKeys()
{
try
{
IEnumerable <AppInsightsTelemetry> appInsightsTelemetries = AppInsightsDeserializer.Deserialize(await this.Request.Content.ReadAsByteArrayAsync().ConfigureAwait(false), true);
List <TelemetryItem> telemetryItems = TelemetryMapper.Map(appInsightsTelemetries).ToList();
// string ip = this.Request.GetClientIp();
string ip = "0.0.0.0";
//items might come with various telemetry key in one request (when there are multiple instances of telemetry client)
IEnumerable <IGrouping <Guid, TelemetryItem> > groups = telemetryItems.GroupBy(telemetry => telemetry.TelemetryKey);
//todo - parallelism?
foreach (IGrouping <Guid, TelemetryItem> grouping in groups)
{
TelemetryRootObject program = await this.work.GetMonitoredProgram(grouping.Key).ConfigureAwait(false);
if (program != null)
{
await this.InsertDataInternal(grouping.ToList(), program, ip).ConfigureAwait(false);
}
else
{
this.telemetryClient.TrackException(new InvalidOperationException($"Program with telemetry key [{grouping.Key}] does not exist"), new Dictionary <string, string>()
{
{ $"Method", Routes.PostWithVariousKeys },
{ $"TelemetryKey", grouping.Key.ToString() },
});
}
}
return(await Task.FromResult(this.StatusCode(HttpStatusCode.Accepted)).ConfigureAwait(false));
}
catch (Exception e)
{
this.telemetryClient.TrackException(e, new Dictionary <string, string>()
{
{ $"Method", Routes.PostWithVariousKeys },
});
throw;
}
}
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 static async Task <TelemetryRootObject> GetRootObjectOrAddIfNotExists(TelimenaTelemetryContext telemetryContext, TelimenaPortalContext portalContext, Guid telemetryKey)
{
var prg = await portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false);
if (prg == null)
{
return(null);
}
var rootObject = await telemetryContext.TelemetryRootObjects.FirstOrDefaultAsync(x => x.ProgramId == prg.Id).ConfigureAwait(false);
if (rootObject == null)
{
rootObject = new TelemetryRootObject
{
ProgramId = prg.Id,
TelemetryKey = prg.TelemetryKey,
};
telemetryContext.TelemetryRootObjects.Add(rootObject);
return(rootObject);
}
return(rootObject);
}
public async Task <IHttpActionResult> PostBasic(Guid telemetryKey, BasicTelemetryItem request)
{
if (request == null)
{
request = new BasicTelemetryItem();
}
TelemetryRootObject program = await this.work.GetMonitoredProgram(telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new BadRequestException($"Program with telemetry key [{telemetryKey}] does not exist");
}
if (!Version.TryParse(request.ProgramVersion, out _))
{
request.ProgramVersion = "0.0.0.0";
}
TelemetryItem item = new TelemetryItem
{
UserIdentifier = request.UserIdentifier
, EntryKey = request.EventName
, Properties = request.Properties
, Measurements = request.Metrics
, VersionData = new VersionData(request.ProgramVersion, request.ProgramVersion)
, Timestamp = request.Timestamp
};
string ip = this.Request.GetClientIp();
await this.InsertDataInternal(new [] { item }, program, ip).ConfigureAwait(false);
return(await Task.FromResult(this.StatusCode(HttpStatusCode.OK)).ConfigureAwait(false));
}
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 Task InsertDataInternal(IEnumerable <TelemetryItem> items, TelemetryRootObject program, string ip)
{
return(TelemetryControllerHelpers.InsertData(this.work, items.ToList(), program, ip));
}
public void InsertMonitoredProgram(TelemetryRootObject program)
{
this.TelemetryRootObjects.Add(program);
}
private static IEnumerable <IEnumerable <ITelemetryAware> > GetCollections(IEnumerable <TelemetryItemTypes> types, TelemetryRootObject program)
{
foreach (TelemetryItemTypes telemetryItemType in types)
{
switch (telemetryItemType)
{
case TelemetryItemTypes.Event:
yield return(program.Events);
break;
case TelemetryItemTypes.View:
yield return(program.Views);
break;
case TelemetryItemTypes.LogMessage:
case TelemetryItemTypes.Exception:
default:
break;
}
}
}
public async Task InsertDataInternal(IReadOnlyCollection <TelemetryItem> items, TelemetryRootObject program, string ip)
{
Stopwatch sw = Stopwatch.StartNew();
List <TelemetrySummary> _ = await TelemetryControllerHelpers.InsertData(this.work, items.ToList(), program, ip);
sw.Stop();
this.telemetryClient.TrackEvent("InsertTelemetryData", new Dictionary <string, string>()
{
{ $"TelemetryItemsCount", items.Count.ToString() },
{ $"ExecutionTime", sw.ElapsedMilliseconds.ToString() },
{ $"ProgramId", program.ProgramId.ToString() },
{ $"TelemetryKey", program.TelemetryKey.ToString() },
});
}
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);
}
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 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);
}
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);
}
