public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("#app");
builder.Services.AddSingleton(sp => new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
// Add antd
builder.Services.AddAntDesign();
builder.Services.AddSingleton <VirtualNetwork>();
builder.Services.AddBlazorApplicationInsights(async applicationInsights =>
{
var telemetryItem = new TelemetryItem()
{
Tags = new Dictionary <string, object>()
{
{ "ai.cloud.role", "SPA" },
{ "ai.cloud.roleInstance", "vnet-planner" },
}
};
await applicationInsights.AddTelemetryInitializer(telemetryItem);
});
builder.Services.AddBlazorDownloadFile();
var host = builder.Build();
var vnetState = host.Services.GetRequiredService <VirtualNetwork>();
await vnetState.Initialize();
await host.RunAsync();
}
public async Task <ActionResult <TelemetryItem> > Post(TelemetryItem item)
{
_context.TelemetryItems.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction("Get", new { id = item.Id }, item));
}
protected void DebugTelemetryItems(Envelope[] telemetries)
{
StringBuilder builder = new StringBuilder();
foreach (Envelope telemetry in telemetries)
{
TelemetryItem <RemoteDependencyData> dependency = telemetry as TelemetryItem <RemoteDependencyData>;
if (dependency != null)
{
var data = ((TelemetryItem <RemoteDependencyData>)dependency).data.baseData;
builder.AppendLine($"{dependency} - {data.data} - {((TelemetryItem<RemoteDependencyData>)dependency).time} - {data.duration} - {data.id} - {data.name} - {data.resultCode} - {data.success} - {data.target} - {data.type}");
}
else
{
TelemetryItem <RequestData> request = telemetry as TelemetryItem <RequestData>;
if (request != null)
{
var data = ((TelemetryItem <RequestData>)request).data.baseData;
builder.AppendLine($"{request} - {data.url} - {((TelemetryItem<RequestData>)request).time} - {data.duration} - {data.id} - {data.name} - {data.success} - {data.responseCode}");
}
else
{
TelemetryItem <ExceptionData> exception = telemetry as TelemetryItem <ExceptionData>;
if (exception != null)
{
var data = ((TelemetryItem <ExceptionData>)exception).data.baseData;
builder.AppendLine($"{exception} - {data.exceptions[0].message} - {data.exceptions[0].stack} - {data.exceptions[0].typeName} - {data.severityLevel}");
}
else
{
TelemetryItem <MessageData> message = telemetry as TelemetryItem <MessageData>;
if (message != null)
{
var data = ((TelemetryItem <MessageData>)message).data.baseData;
builder.AppendLine($"{message} - {data.message} - {data.severityLevel}");
}
else
{
TelemetryItem <MetricData> metric = telemetry as TelemetryItem <MetricData>;
if (metric != null)
{
var data = ((TelemetryItem <MetricData>)metric).data.baseData;
builder.AppendLine($"{metric.ToString()} - {metric.data}- {metric.name} - {data.metrics.Count}");
foreach (var metricVal in data.metrics)
{
builder.AppendLine($"{metricVal.name} {metricVal.value}");
}
}
else
{
builder.AppendLine($"{telemetry.ToString()} - {telemetry.time}");
}
}
}
}
}
}
this.output.WriteLine(builder.ToString());
}
internal static List <TelemetryItem> OtelToAzureMonitorTrace(Batch <Activity> batchActivity, string roleName, string roleInstance, string instrumentationKey)
{
List <TelemetryItem> telemetryItems = new List <TelemetryItem>();
TelemetryItem telemetryItem;
foreach (var activity in batchActivity)
{
MonitorBase telemetryData = new MonitorBase();
var monitorTags = TraceHelper.EnumerateActivityTags(activity);
telemetryItem = new TelemetryItem(activity, ref monitorTags);
telemetryItem.InstrumentationKey = instrumentationKey;
telemetryItem.SetResource(roleName, roleInstance);
switch (activity.GetTelemetryType())
{
case TelemetryType.Request:
telemetryData.BaseType = "RequestData";
telemetryData.BaseData = new RequestData(Version, activity, ref monitorTags);
break;
case TelemetryType.Dependency:
telemetryData.BaseType = "RemoteDependencyData";
telemetryData.BaseData = new RemoteDependencyData(Version, activity, ref monitorTags);
break;
}
telemetryItem.Data = telemetryData;
telemetryItems.Add(telemetryItem);
}
return(telemetryItems);
}
internal static List <TelemetryItem> OtelToAzureMonitorMetrics(Batch <Metric> batch, string roleName, string roleInstance, string instrumentationKey)
{
List <TelemetryItem> telemetryItems = new List <TelemetryItem>();
TelemetryItem telemetryItem;
foreach (var metric in batch)
{
if (metric.MetricType == MetricType.DoubleSum || metric.MetricType == MetricType.DoubleGauge)
{
foreach (ref readonly var metricPoint in metric.GetMetricPoints())
{
telemetryItem = new TelemetryItem(metricPoint.EndTime.UtcDateTime, roleName, roleInstance, instrumentationKey);
telemetryItem.Data = new MonitorBase
{
BaseType = "MetricData",
BaseData = new MetricsData(Version, metric, metricPoint)
};
telemetryItems.Add(telemetryItem);
}
}
else
{
// log not supported
}
}
return(telemetryItems);
}
private async void ProcessTelemetry(string jsonString)
{
var json = JObject.Parse(jsonString);
// var name = json.name.value;
// foreach(var item in json.value.timeseries.data)
// {
// var telemetry = new TelemetryItem(name, item.timeStamp, item.average);
// }
var telemetry = new TelemetryItem(DateTime.Now.ToUniversalTime(), ((JArray)json["value"][0]["timeseries"][0]["data"]).Count);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var content = new StringContent(JsonConvert.SerializeObject(telemetry), Encoding.UTF8, "application/json");
using (HttpResponseMessage response = await client.PostAsync(uriTelemetryApi, content))
{
if (!response.IsSuccessStatusCode)
{
// WHAHAHHAHAAA!!!
}
}
}
}
internal static List <TelemetryItem> OtelToAzureMonitorLogs(Batch <LogRecord> batchLogRecord, string roleName, string roleInstance, string instrumentationKey)
{
List <TelemetryItem> telemetryItems = new List <TelemetryItem>();
TelemetryItem telemetryItem;
foreach (var logRecord in batchLogRecord)
{
telemetryItem = new TelemetryItem(logRecord, roleName, roleInstance, instrumentationKey);
if (logRecord.Exception != null)
{
telemetryItem.Data = new MonitorBase
{
BaseType = "ExceptionData",
BaseData = new TelemetryExceptionData(Version, logRecord),
};
}
else
{
telemetryItem.Data = new MonitorBase
{
BaseType = "MessageData",
BaseData = new MessageData(Version, logRecord),
};
}
telemetryItems.Add(telemetryItem);
}
return(telemetryItems);
}
private static TelemetryItem Build(AppInsightsTelemetry appInsightsTelemetry)
{
Dictionary <string, string> appInsightsProperties = appInsightsTelemetry.Data?.BaseData?.Properties;
//bear in mind - if something goes wrong, properties might be null
TelemetryItem item = new TelemetryItem()
{
Timestamp = appInsightsTelemetry.Time,
VersionData = GetVersionData(appInsightsProperties),
UserIdentifier = appInsightsTelemetry.Tags?.AiUserId,
AuthenticatedUserIdentifier = appInsightsTelemetry.Tags?.AiUserAuthUserId,
Properties = GetFilteredProperties(appInsightsProperties),
Measurements = appInsightsTelemetry.Data?.BaseData?.Measurements,
TelemetryItemType = GetItemType(appInsightsTelemetry),
EntryKey = appInsightsTelemetry.Data?.BaseData?.Name ?? "MissingKey",
Sequence = appInsightsTelemetry.Seq,
LogMessage = appInsightsTelemetry.Data?.BaseData?.Message
};
MapTelemetryKey(appInsightsProperties, item);
MapLogLevel(appInsightsTelemetry, item);
MapExceptionProperties(appInsightsTelemetry, item);
HandleNullPropertiesError(appInsightsTelemetry, appInsightsProperties, item);
return(item);
}
internal static List <TelemetryItem> OtelToAzureMonitorMetrics(Batch <Metric> batch, string roleName, string roleInstance, string instrumentationKey)
{
List <TelemetryItem> telemetryItems = new List <TelemetryItem>();
TelemetryItem telemetryItem;
foreach (var metric in batch)
{
if (metric.MetricType == MetricType.DoubleSum || metric.MetricType == MetricType.DoubleGauge)
{
foreach (ref var metricPoint in metric.GetMetricPoints())
{
string name = "Metric";
string utcTime = TelemetryItem.FormatUtcTimestamp(metricPoint.EndTime.UtcDateTime);
telemetryItem = new TelemetryItem(name, utcTime);
telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()] = SdkVersionUtils.SdkVersion;
telemetryItem.InstrumentationKey = instrumentationKey;
telemetryItem.SetResource(roleName, roleInstance);
telemetryItem.Data = new MonitorBase
{
BaseType = "MetricData",
BaseData = new MetricsData(version, metric, ref metricPoint)
};
telemetryItems.Add(telemetryItem);
}
}
else
{
// log not supported
}
}
return(telemetryItems);
}
public void HttpMethodAndHttpRouteIsUsedForHttpRequestOperationName(string route)
{
using ActivitySource activitySource = new ActivitySource(ActivitySourceName);
using var activity = activitySource.StartActivity(
ActivityName,
ActivityKind.Server,
null,
startTime: DateTime.UtcNow);
var resource = CreateTestResource();
activity.DisplayName = "/getaction";
activity.SetTag(SemanticConventions.AttributeHttpMethod, "GET");
activity.SetTag(SemanticConventions.AttributeHttpRoute, route);
activity.SetTag(SemanticConventions.AttributeHttpUrl, "https://www.foo.bar/search");
string expectedOperationName;
if (route == "{controller}/{action}/{id}" || route == null)
{
expectedOperationName = "GET /search";
}
else
{
expectedOperationName = $"GET {route}";
}
var monitorTags = TraceHelper.EnumerateActivityTags(activity);
var telemetryItem = new TelemetryItem(activity, ref monitorTags);
Assert.Equal(expectedOperationName, telemetryItem.Tags[ContextTagKeys.AiOperationName.ToString()]);
}
/// <summary>
/// Validates Runtime Dependency Telemetry values.
/// </summary>
/// <param name="itemToValidate">RDD Item to be validated.</param>
/// <param name="accessTimeMax">Expected maximum limit for access time.</param>
/// <param name="successFlagExpected">Expected value for success flag.</param>
public static void Validate(
TelemetryItem <RemoteDependencyData> itemToValidate,
TimeSpan accessTimeMax,
bool successFlagExpected)
{
string actualSdkVersion = itemToValidate.tags[new ContextTagKeys().InternalSdkVersion];
Assert.IsTrue(actualSdkVersion.Contains(DeploymentAndValidationTools.ExpectedSDKPrefix), "Actual version:" + actualSdkVersion);
// Validate is within expected limits
var accessTime = TimeSpan.Parse(itemToValidate.data.baseData.duration);
// DNS resolution may take up to 15 seconds https://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.timeout(v=vs.110).aspx.
// In future when tests will be refactored we should re-think failed http calls validation policy - need to validate resposnes that actually fails on GetResponse,
// not only those made to not-existing domain.
var accessTimeMaxPlusDnsResolutionTime = accessTimeMax.Add(TimeSpan.FromSeconds(15));
if (successFlagExpected)
{
Assert.IsTrue(accessTime.Ticks > 0, "Access time should be above zero");
}
else
{
Assert.IsTrue(accessTime.Ticks >= 0, "Access time should be zero or above for failed calls");
}
Assert.IsTrue(accessTime < accessTimeMaxPlusDnsResolutionTime, string.Format("Access time of {0} exceeds expected max of {1}", accessTime, accessTimeMaxPlusDnsResolutionTime));
// Validate success flag
var successFlagActual = itemToValidate.data.baseData.success;
Assert.AreEqual(successFlagExpected, successFlagActual, "Success flag collected is wrong");
}
internal static TelemetryItem GetTelemetryItem(LogRecord logRecord, string instrumentationKey)
{
var name = PartA_Name_Mapping[TelemetryType.Message];
var time = FormatUtcTimestamp(logRecord.Timestamp);
TelemetryItem telemetryItem = new TelemetryItem(name, time)
{
InstrumentationKey = instrumentationKey
};
// TODO: I WAS TOLD THIS MIGHT BE CHANGING. IGNORING FOR NOW.
//InitRoleInfo(activity);
//telemetryItem.Tags[ContextTagKeys.AiCloudRole.ToString()] = RoleName;
//telemetryItem.Tags[ContextTagKeys.AiCloudRoleInstance.ToString()] = RoleInstance;
if (logRecord.TraceId != default)
{
telemetryItem.Tags[ContextTagKeys.AiOperationId.ToString()] = logRecord.TraceId.ToHexString();
}
if (logRecord.SpanId != default)
{
telemetryItem.Tags[ContextTagKeys.AiOperationParentId.ToString()] = logRecord.SpanId.ToHexString();
}
telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()] = SdkVersionUtils.SdkVersion;
return(telemetryItem);
}
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));
}
}
public void ValidateTelemetryItem_DefaultActivity_DefaultResource()
{
using ActivitySource activitySource = new ActivitySource(ActivitySourceName);
using var activity = activitySource.StartActivity(
ActivityName,
ActivityKind.Client,
parentContext: default,
startTime: DateTime.UtcNow);
var resource = CreateTestResource();
var monitorTags = TraceHelper.EnumerateActivityTags(activity);
var telemetryItem = new TelemetryItem(activity, ref monitorTags);
var resourceParser = new ResourceParser();
resourceParser.UpdateRoleNameAndInstance(resource);
telemetryItem.SetResource(resourceParser.RoleName, resourceParser.RoleInstance);
Assert.Equal("RemoteDependency", telemetryItem.Name);
Assert.Equal(TelemetryItem.FormatUtcTimestamp(activity.StartTimeUtc), telemetryItem.Time);
Assert.StartsWith("unknown_service", telemetryItem.Tags[ContextTagKeys.AiCloudRole.ToString()]);
Assert.Equal(Dns.GetHostName(), telemetryItem.Tags[ContextTagKeys.AiCloudRoleInstance.ToString()]);
Assert.NotNull(telemetryItem.Tags[ContextTagKeys.AiOperationId.ToString()]);
Assert.NotNull(telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()]);
Assert.Throws <KeyNotFoundException>(() => telemetryItem.Tags[ContextTagKeys.AiOperationParentId.ToString()]);
}
public async static Task SendToMissionControlAsync(TelemetryItem telemetry)
{
var client = TopicClient.CreateFromConnectionString(Common.CoreConstants.MissionControlTransmissionConnection, Common.CoreConstants.MissionEventName);
BrokeredMessage bm = new BrokeredMessage();
bm.Label = telemetry.UserId;
bm.Properties["UserId"] = telemetry.UserId;
bm.Properties["DisplayName"] = telemetry.DisplayName;
bm.Properties["Tagline"] = telemetry.Tagline;
bm.Properties["Altitude"] = telemetry.Altitude;
bm.Properties["DescentRate"] = telemetry.DescentRate;
bm.Properties["Fuel"] = telemetry.Fuel;
bm.Properties["Thrust"] = telemetry.Thrust;
try
{
await client.SendAsync(bm);
}
catch
{
}
return;
}
internal static TelemetryItem GetTelemetryItem(Activity activity, ref TagEnumerationState monitorTags, Resource resource, string instrumentationKey)
{
TelemetryItem telemetryItem = new TelemetryItem(PartA_Name_Mapping[activity.GetTelemetryType()], FormatUtcTimestamp(activity.StartTimeUtc))
{
InstrumentationKey = instrumentationKey
};
InitRoleInfo(resource);
if (activity.ParentSpanId != default)
{
telemetryItem.Tags[ContextTagKeys.AiOperationParentId.ToString()] = activity.ParentSpanId.ToHexString();
}
telemetryItem.Tags[ContextTagKeys.AiCloudRole.ToString()] = RoleName;
telemetryItem.Tags[ContextTagKeys.AiCloudRoleInstance.ToString()] = RoleInstance;
telemetryItem.Tags[ContextTagKeys.AiOperationId.ToString()] = activity.TraceId.ToHexString();
// todo: update swagger to include this key.
telemetryItem.Tags["ai.user.userAgent"] = AzMonList.GetTagValue(ref monitorTags.PartBTags, SemanticConventions.AttributeHttpUserAgent)?.ToString();
// we only have mapping for server spans
// todo: non-server spans
if (activity.Kind == ActivityKind.Server)
{
telemetryItem.Tags[ContextTagKeys.AiOperationName.ToString()] = GetOperationName(activity, ref monitorTags.PartBTags);
telemetryItem.Tags[ContextTagKeys.AiLocationIp.ToString()] = GetLocationIp(ref monitorTags.PartBTags);
}
telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()] = SdkVersionUtils.SdkVersion;
return(telemetryItem);
}
private static void AddLoggingAndApplicationInsights(WebAssemblyHostBuilder builder)
{
var instrumentationKey = builder.Configuration.GetValue <string>("ApplicationInsights:InstrumentationKey");
builder.Services.AddBlazorApplicationInsights(async applicationInsights =>
{
await applicationInsights.SetInstrumentationKey(instrumentationKey);
await applicationInsights.LoadAppInsights();
var telemetryItem = new TelemetryItem()
{
Tags = new Dictionary <string, object>()
{
{ "ai.cloud.role", "Web.Client" },
// { "ai.cloud.roleInstance", "..." },
}
};
await applicationInsights.AddTelemetryInitializer(telemetryItem);
}, addILoggerProvider: true);
builder.Logging.AddFilter <ApplicationInsightsLoggerProvider>(level => (level == LogLevel.Error) || (level == LogLevel.Critical));
#if DEBUG
builder.Logging.SetMinimumLevel(LogLevel.Debug);
#endif
}
public void GeneratePartAEnvelope_Activity_WithResource()
{
using ActivitySource activitySource = new ActivitySource(ActivitySourceName);
using var activity = activitySource.StartActivity(
ActivityName,
ActivityKind.Client,
parentContext: default,
startTime: DateTime.UtcNow);
var resource = CreateTestResource(serviceName: "my-service", serviceInstance: "my-instance");
var monitorTags = TraceHelper.EnumerateActivityTags(activity);
var telemetryItem = new TelemetryItem(activity, ref monitorTags);
var resourceParser = new ResourceParser();
resourceParser.UpdateRoleNameAndInstance(resource);
telemetryItem.SetResource(resourceParser.RoleName, resourceParser.RoleInstance);
Assert.Equal("RemoteDependency", telemetryItem.Name);
Assert.Equal(TelemetryItem.FormatUtcTimestamp(activity.StartTimeUtc), telemetryItem.Time);
Assert.Equal("my-service", telemetryItem.Tags[ContextTagKeys.AiCloudRole.ToString()]);
Assert.Equal("my-instance", telemetryItem.Tags[ContextTagKeys.AiCloudRoleInstance.ToString()]);
Assert.Equal(activity.TraceId.ToHexString(), telemetryItem.Tags[ContextTagKeys.AiOperationId.ToString()]);
Assert.Equal(SdkVersionUtils.SdkVersion, telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()]);
Assert.Throws <KeyNotFoundException>(() => telemetryItem.Tags[ContextTagKeys.AiOperationParentId.ToString()]);
}
public static IServiceCollection AddBlazorServices(this IServiceCollection services)
{
services.AddScoped <ICatalogBrandService, CachedCatalogBrandServiceDecorator>();
services.AddScoped <CatalogBrandService>();
services.AddScoped <ICatalogTypeService, CachedCatalogTypeServiceDecorator>();
services.AddScoped <CatalogTypeService>();
services.AddScoped <ICatalogItemService, CachedCatalogItemServiceDecorator>();
services.AddScoped <CatalogItemService>();
//Application Insights
services.AddBlazorApplicationInsights(async applicationInsights =>
{
var telemetryItem = new TelemetryItem()
{
Tags = new Dictionary <string, object>()
{
{ "ai.cloud.role", "SPA" },
{ "ai.cloud.roleInstance", "Blazor Wasm" },
}
};
await applicationInsights.AddTelemetryInitializer(telemetryItem);
});
return(services);
}
public void GeneratePartAEnvelope_Activity_WithParentSpanId()
{
using ActivitySource activitySource = new ActivitySource(ActivitySourceName);
using var activity = activitySource.StartActivity(
ActivityName,
ActivityKind.Client,
parentContext: new ActivityContext(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom(), ActivityTraceFlags.Recorded),
startTime: DateTime.UtcNow);
var resource = CreateTestResource();
var monitorTags = TraceHelper.EnumerateActivityTags(activity);
var telemetryItem = new TelemetryItem(activity, ref monitorTags);
var resourceParser = new ResourceParser();
resourceParser.UpdateRoleNameAndInstance(resource);
telemetryItem.SetResource(resourceParser.RoleName, resourceParser.RoleInstance);
Assert.Equal("RemoteDependency", telemetryItem.Name);
Assert.Equal(TelemetryItem.FormatUtcTimestamp(activity.StartTimeUtc), telemetryItem.Time);
Assert.StartsWith("unknown_service", telemetryItem.Tags[ContextTagKeys.AiCloudRole.ToString()]);
Assert.Equal(Dns.GetHostName(), telemetryItem.Tags[ContextTagKeys.AiCloudRoleInstance.ToString()]);
Assert.NotNull(telemetryItem.Tags[ContextTagKeys.AiOperationId.ToString()]);
Assert.NotNull(telemetryItem.Tags[ContextTagKeys.AiInternalSdkVersion.ToString()]);
Assert.Equal(activity.ParentSpanId.ToHexString(), telemetryItem.Tags[ContextTagKeys.AiOperationParentId.ToString()]);
}
/// <summary>
/// Maps the specified basic item.
/// </summary>
/// <param name="telemetryKey"></param>
/// <param name="basicItem">The basic item.</param>
/// <returns>TelemetryItem.</returns>
public static TelemetryItem Map(Guid telemetryKey, BasicTelemetryItem basicItem)
{
if (!Version.TryParse(basicItem.ProgramVersion, out _))
{
basicItem.ProgramVersion = "0.0.0.0";
}
TelemetryItem item = new TelemetryItem
{
TelemetryKey = telemetryKey,
UserIdentifier = basicItem.UserIdentifier,
TelemetryItemType = basicItem.TelemetryItemType,
LogMessage = basicItem.LogMessage,
EntryKey = basicItem.EventName,
Sequence = "NotSpecified",
Properties = basicItem.Properties,
Measurements = basicItem.Metrics,
VersionData = new VersionData(basicItem.ProgramVersion, basicItem.ProgramVersion),
Timestamp = basicItem.Timestamp
};
if (basicItem.TelemetryItemType == TelemetryItemTypes.Exception)
{
item.Exceptions = new List <TelemetryItem.ExceptionInfo>();
item.Exceptions.Add(new TelemetryItem.ExceptionInfo()
{
Message = basicItem.ErrorMessage
});
}
return(item);
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
builder.Services.AddTransient(sp => new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddBlazorApplicationInsights(async applicationInsights =>
{
var telemetryItem = new TelemetryItem()
{
Tags = new Dictionary <string, object>()
{
{ "ai.cloud.role", "SPA" },
{ "ai.cloud.roleInstance", "Blazor Wasm" },
}
};
await applicationInsights.AddTelemetryInitializer(telemetryItem);
});
await builder.Build().RunAsync();
}
private static void Validate(TelemetryItem <RemoteDependencyData> itemToValidate,
string targetExpected,
string commandNameExpected,
TimeSpan accessTimeMax,
bool successFlagExpected,
string sqlErrorCodeExpected,
string sqlErrorMessageExpected)
{
Assert.IsTrue(itemToValidate.data.baseData.target.Contains(targetExpected),
"The remote dependancy target is incorrect. Expected: " + targetExpected +
". Collected: " + itemToValidate.data.baseData.target);
Assert.AreEqual(sqlErrorCodeExpected, itemToValidate.data.baseData.resultCode);
//If the command name is expected to be empty, the deserializer will make the CommandName null
if ("rdddsc" == DeploymentAndValidationTools.ExpectedSqlSDKPrefix)
{
// Additional checks for profiler collection
if (!string.IsNullOrEmpty(sqlErrorMessageExpected))
{
Assert.AreEqual(sqlErrorMessageExpected, itemToValidate.data.baseData.properties["ErrorMessage"]);
}
if (string.IsNullOrEmpty(commandNameExpected))
{
Assert.IsNull(itemToValidate.data.baseData.data);
}
else
{
Assert.AreEqual(commandNameExpected, itemToValidate.data.baseData.data, "The command name is incorrect");
}
}
DeploymentAndValidationTools.Validate(itemToValidate, accessTimeMax, successFlagExpected, sqlErrorCodeExpected);
}
private async Task Track(string customEvent, string mectrics)
{
TelemetryItem telemetryItem = new TelemetryItem();
telemetryItem.CustomEvent = customEvent;
telemetryItem.Metrics = mectrics;
await InsertTelemetryItem(telemetryItem);
}
protected void ValidateExceptionTelemetry(TelemetryItem <ExceptionData> exceptionTelemetry, TelemetryItem <RequestData> request, int expectedExceptionsCount)
{
Assert.AreEqual(this.Config.IKey, exceptionTelemetry.iKey, "iKey is not the same as in config file for exception");
Assert.AreEqual(request.tags[new ContextTagKeys().OperationId], exceptionTelemetry.tags[new ContextTagKeys().OperationId], "Operation id is incorrect");
Assert.AreEqual(expectedExceptionsCount, exceptionTelemetry.data.baseData.exceptions.Count, "Exceptions count is incorrect");
Assert.IsTrue(exceptionTelemetry.tags.Where((x) => { return(x.Key.StartsWith("ai.cloud")); }).Count() > 0, "Cloud was not collected");
}
protected void ValidateExceptionTelemetry(TelemetryItem<ExceptionData> exceptionTelemetry, TelemetryItem<RequestData> request, int expectedExceptionsCount)
{
Assert.AreEqual(this.Config.IKey, exceptionTelemetry.iKey, "iKey is not the same as in config file for exception");
Assert.AreEqual(request.tags[new ContextTagKeys().OperationId], exceptionTelemetry.tags[new ContextTagKeys().OperationId], "Operation id is incorrect");
Assert.AreEqual(expectedExceptionsCount, exceptionTelemetry.data.baseData.exceptions.Count, "Exceptions count is incorrect");
Assert.IsTrue(exceptionTelemetry.tags.Where((x)=> { return x.Key.StartsWith("ai.cloud"); }).Count() > 0, "Cloud was not collected");
}
private static void MapLogLevel(AppInsightsTelemetry appInsightsTelemetry, TelemetryItem item)
{
if (appInsightsTelemetry.Data.BaseData.SeverityLevel != null)
{
if (Enum.TryParse(appInsightsTelemetry.Data.BaseData.SeverityLevel, out SeverityLevel enumerized))
{
item.LogLevel = Map(enumerized);
}
}
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <EventData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, EventData>(telemetry);
Assert.AreEqual("Session ended", envelope.data.baseData.name);
Assert.AreEqual(2, envelope.data.baseData.ver);
}
public static void VerifyDependency(TelemetryItem telemetryItem, ExpectedTelemetryItemValues expectedVars)
{
Assert.Equal("RemoteDependency", telemetryItem.Name);
Assert.Equal(nameof(RemoteDependencyData), telemetryItem.Data.BaseType);
var data = (RemoteDependencyData)telemetryItem.Data.BaseData;
Assert.Equal(expectedVars.Name, data.Name);
Assert.Equal(expectedVars.CustomProperties, data.Properties);
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <SessionStateData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, SessionStateData>(telemetry);
Assert.Equal(AI.SessionState.End, envelope.data.baseData.state);
Assert.Equal(2, envelope.data.baseData.ver);
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <SessionStateData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, SessionStateData>(telemetry);
Assert.Equal(DataPlatformModel.SessionState.End, envelope.Data.BaseData.State);
Assert.Equal(2, envelope.Data.BaseData.Ver);
}
protected void ValidateExceptionTelemetry(TelemetryItem<ExceptionData> exceptionTelemetry, TelemetryItem<RequestData> request, int expectedExceptionsCount)
{
Assert.AreEqual(this.Config.IKey, exceptionTelemetry.IKey, "iKey is not the same as in config file for exception");
Assert.AreEqual(request.OperationContext.Id, exceptionTelemetry.OperationContext.Id, "Operation id is incorrect");
Assert.AreEqual("Platform", exceptionTelemetry.Data.BaseData.HandledAt, "handledAt is incorrect");
Assert.AreEqual(expectedExceptionsCount, exceptionTelemetry.Data.BaseData.Exceptions.Count, "Exceptions count is incorrect");
Assert.IsNotNull(exceptionTelemetry.DeviceContext, "Device was not collected");
}
protected void TestWebApplicationHelper(string requestName, string requestUrl, string responseCode, bool success, TelemetryItem<RequestData> item, DateTimeOffset testStart, DateTimeOffset testFinish)
{
Assert.AreEqual(this.Config.IKey, item.IKey, "iKey is not the same as in config file");
Assert.AreEqual(requestName, item.OperationContext.Name);
Assert.AreEqual(requestUrl, item.Data.BaseData.Url);
Assert.AreEqual(responseCode, item.Data.BaseData.ResponseCode);
Assert.AreEqual(success, item.Data.BaseData.Success);
double duration = Math.Floor(item.Data.BaseData.Duration.TotalMilliseconds);
Assert.IsTrue(duration >= 0, "Duration is negative: " + duration);
Assert.IsTrue((testFinish - testStart).TotalMilliseconds >= duration, "Duration is incorrect: " + duration);
}
protected void TestWebApplicationHelper(string requestName, string requestUrl, string responseCode, bool success, TelemetryItem<RequestData> item, DateTimeOffset testStart, DateTimeOffset testFinish)
{
Assert.AreEqual(this.Config.IKey, item.iKey, "iKey is not the same as in config file");
Assert.AreEqual(requestName, item.tags[new ContextTagKeys().OperationName]);
Assert.AreEqual(requestUrl, item.data.baseData.url);
Assert.AreEqual(responseCode, item.data.baseData.responseCode);
Assert.AreEqual(success, item.data.baseData.success);
double duration = Math.Floor(TimeSpan.Parse(item.data.baseData.duration).TotalMilliseconds);
Assert.IsTrue(duration >= 0, "Duration is negative: " + duration);
Assert.IsTrue((testFinish - testStart).TotalMilliseconds >= duration, "Duration is incorrect: " + duration);
}
private void ReceiveRequestAndSession(
int testListenerTimeoutInMs,
out TelemetryItem<RequestData> requestItem,
out TelemetryItem<SessionStateData> sessionItem)
{
var items = Listener.ReceiveItemsOfTypes<TelemetryItem<RequestData>, TelemetryItem<SessionStateData>>(
2,
testListenerTimeoutInMs);
// One item is request, the other one is sessionState.
int requestItemIndex = (items[0] is TelemetryItem<RequestData>) ? 0 : 1;
int sessionStateItemIndex = (requestItemIndex == 0) ? 1 : 0;
sessionItem = (TelemetryItem<SessionStateData>)items[sessionStateItemIndex];
requestItem = (TelemetryItem<RequestData>)items[requestItemIndex];
}
private static void AssertCustomCounterReported(TelemetryItem[] counterItems, string metricName, bool reported = true)
{
bool counterReported = counterItems.Any(
item =>
{
var metricData = item as TelemetryItem<MetricData>;
return metricData != null && metricData.Data.BaseData.Metrics[0].Name == metricName;
});
if (reported)
{
Assert.IsTrue(counterReported);
}
else
{
Assert.IsFalse(counterReported);
}
}
private static void AssertDefaultCounterReported(TelemetryItem[] counterItems, string categoryName, string counterName, bool reported = true)
{
bool counterReported = counterItems.Any(
item =>
{
var perfData = item as TelemetryItem<PerformanceCounterData>;
return perfData != null && perfData.Data.BaseData.CategoryName == categoryName
&& perfData.Data.BaseData.CounterName == counterName;
});
if (reported)
{
Assert.IsTrue(counterReported);
}
else
{
Assert.IsFalse(counterReported);
}
}
private void Validate(TelemetryItem<RemoteDependencyData> itemToValidate,
Uri expectedUrl,
TimeSpan accessTimeMax,
bool successFlagExpected,
string verb)
{
if ("rddp" == DeploymentAndValidationTools.ExpectedSDKPrefix)
{
Assert.AreEqual(verb + " " + expectedUrl.AbsolutePath, itemToValidate.data.baseData.name, "For StatusMonitor implementation we expect verb to be collected.");
Assert.AreEqual(expectedUrl.Host, itemToValidate.data.baseData.target);
Assert.AreEqual(expectedUrl.OriginalString, itemToValidate.data.baseData.data);
}
DeploymentAndValidationTools.Validate(itemToValidate, accessTimeMax, successFlagExpected);
}
private void Validate(TelemetryItem<RemoteDependencyData> itemToValidate,
string targetExpected,
string commandNameExpected,
TimeSpan accessTimeMax,
bool successFlagExpected,
string sqlErrorCodeExpected,
string sqlErrorMessageExpected)
{
// For http name is validated in test itself
Assert.IsTrue(itemToValidate.data.baseData.target.Contains(targetExpected),
"The remote dependancy target is incorrect. Expected: " + targetExpected +
". Collected: " + itemToValidate.data.baseData.target);
Assert.AreEqual(sqlErrorCodeExpected, itemToValidate.data.baseData.resultCode);
//If the command name is expected to be empty, the deserializer will make the CommandName null
if ("rddp" == DeploymentAndValidationTools.ExpectedSDKPrefix)
{
// Additional checks for profiler collection
if (!string.IsNullOrEmpty(sqlErrorMessageExpected))
{
Assert.AreEqual(sqlErrorMessageExpected, itemToValidate.data.baseData.properties["ErrorMessage"]);
}
if (string.IsNullOrEmpty(commandNameExpected))
{
Assert.IsNull(itemToValidate.data.baseData.data);
}
else
{
Assert.IsTrue(itemToValidate.data.baseData.data.Equals(commandNameExpected), "The command name is incorrect");
}
}
DeploymentAndValidationTools.Validate(itemToValidate, accessTimeMax, successFlagExpected);
}
/// <summary>
/// Validates Runtime Dependency Telemetry values.
/// </summary>
/// <param name="itemToValidate">RDD Item to be validated.</param>
/// <param name="accessTimeMax">Expected maximum limit for access time.</param>
/// <param name="successFlagExpected">Expected value for success flag.</param>
public static void Validate(
TelemetryItem<RemoteDependencyData> itemToValidate,
TimeSpan accessTimeMax,
bool successFlagExpected)
{
string actualSdkVersion = itemToValidate.tags[new ContextTagKeys().InternalSdkVersion];
Assert.IsTrue(actualSdkVersion.Contains(DeploymentAndValidationTools.ExpectedSDKPrefix), "Actual version:" + actualSdkVersion);
// Validate is within expected limits
var accessTime = TimeSpan.Parse(itemToValidate.data.baseData.duration);
// DNS resolution may take up to 15 seconds https://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.timeout(v=vs.110).aspx.
// In future when tests will be refactored we should re-think failed http calls validation policy - need to validate resposnes that actually fails on GetResponse,
// not only those made to not-existing domain.
var accessTimeMaxPlusDnsResolutionTime = accessTimeMax.Add(TimeSpan.FromSeconds(15));
if (successFlagExpected)
{
Assert.IsTrue(accessTime.Ticks > 0, "Access time should be above zero");
}
else
{
Assert.IsTrue(accessTime.Ticks >= 0, "Access time should be zero or above for failed calls");
}
Assert.IsTrue(accessTime < accessTimeMaxPlusDnsResolutionTime, string.Format("Access time of {0} exceeds expected max of {1}", accessTime, accessTimeMaxPlusDnsResolutionTime));
// Validate success flag
var successFlagActual = itemToValidate.data.baseData.success;
Assert.AreEqual(successFlagExpected, successFlagActual, "Success flag collected is wrong");
}
/// <summary>
/// Validates Runtime Dependency Telemetry values.
/// </summary>
/// <param name="itemToValidate">RDD Item to be validated.</param>
/// <param name="remoteDependencyNameExpected">Expected name.</param>
/// <param name="countExpected">Expected count.</param>
/// <param name="accessTimeMax">Expected maximum limit for access time.</param>
/// <param name="successFlagExpected">Expected value for success flag.</param>
/// <param name="asyncFlagExpected">Expected value for async flag.</param>
private void ValidateRddTelemetryValues(TelemetryItem<RemoteDependencyData> itemToValidate, string remoteDependencyNameExpected, string commandNameExpected, int countExpected, TimeSpan accessTimeMax, bool successFlagExpected, bool asyncFlagExpected)
{
DependencySourceType source = sourceExpected;
Assert.IsTrue(itemToValidate.Data.BaseData.Name.Contains(remoteDependencyNameExpected), "The remote dependancy name is incorrect");
//If the command name is expected to be empty, the deserializer will make the CommandName null
if (DependencySourceType.Apmc == sourceExpected)
{
if (string.IsNullOrEmpty(commandNameExpected))
Assert.IsNull(itemToValidate.Data.BaseData.CommandName);
else
Assert.IsTrue(itemToValidate.Data.BaseData.CommandName.Equals(commandNameExpected), "The command name is incorrect");
}
string actualSdkVersion = itemToValidate.InternalContext.SdkVersion;
if (DependencySourceType.Apmc == sourceExpected)
{
Assert.IsTrue(actualSdkVersion.Contains("rddp"), "Actual version:" + actualSdkVersion);
}
else
{
Assert.IsTrue(actualSdkVersion.Contains("rddf"), "Actual version:" + actualSdkVersion);
}
// Validate is within expected limits
var ticks = (long)(itemToValidate.Data.BaseData.Value * 10000);
var accessTime = TimeSpan.FromTicks(ticks);
// DNS resolution may take up to 15 seconds https://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.timeout(v=vs.110).aspx.
// In future when tests will be refactored we should re-think failed http calls validation policy - need to validate resposnes that actually fails on GetResponse,
// not only those made to not-existing domain.
var accessTimeMaxPlusDnsResolutionTime = accessTimeMax.Add(TimeSpan.FromSeconds(15));
if (successFlagExpected == true)
{
Assert.IsTrue(accessTime.Ticks > 0, "Access time should be above zero");
}
else
{
Assert.IsTrue(accessTime.Ticks >= 0, "Access time should be zero or above for failed calls");
}
Assert.IsTrue(accessTime < accessTimeMaxPlusDnsResolutionTime, string.Format("Access time of {0} exceeds expected max of {1}", accessTime, accessTimeMaxPlusDnsResolutionTime));
// Validate success and async flag values
var successFlagActual = itemToValidate.Data.BaseData.Success;
Assert.AreEqual(successFlagExpected, successFlagActual, "Success flag collected is wrong");
}
