private static void InitializeTelemetry(DependencyTelemetry telemetry, Guid operationId, long timestamp)
{
telemetry.Start(timestamp);
var activity = Activity.Current;
if (activity != null)
{
telemetry.Context.Operation.Id = activity.RootId;
// SQL Client does NOT create and Activity, i.e.
// we initialize SQL dependency using request Activity
// and it is a parent of the SQL dependency
telemetry.Context.Operation.ParentId = activity.Id;
foreach (var item in activity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties[item.Key] = item.Value;
}
}
}
else
{
telemetry.Context.Operation.Id = operationId.ToStringInvariant("N");
}
}
public void StartTimeIsPrecise()
{
double [] timeStampDiff = new double[1000];
DateTimeOffset prevTimestamp = DateTimeOffset.MinValue;
for (int i = 0; i < timeStampDiff.Length; i++)
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
if (i > 0)
{
timeStampDiff[i] = telemetry.Timestamp.Subtract(prevTimestamp).TotalMilliseconds;
Debug.WriteLine(timeStampDiff[i]);
// if timestamp is NOT precise, we'll get precisely 0 which should not ever happen
Assert.IsTrue(timeStampDiff[i] != 0);
}
prevTimestamp = telemetry.Timestamp;
// waste a bit of time, assert result to prevent any optimizations
Assert.IsTrue(ComputeSomethingHeavy() > 0);
}
}
public void OperationTelemetryCanRecordPreciseDurations()
{
var telemetry = new DependencyTelemetry();
long startTime = Stopwatch.GetTimestamp();
telemetry.Start(timestamp: startTime);
// Note: Do not use TimeSpan.FromSeconds because it rounds to the nearest millisecond.
var expectedDuration = TimeSpan.Parse("00:00:00.1234560");
// Ensure we choose a time that has a fractional (non-integral) number of milliseconds
Assert.NotEqual(Math.Round(expectedDuration.TotalMilliseconds), expectedDuration.TotalMilliseconds);
double durationInStopwatchTicks = Stopwatch.Frequency * expectedDuration.TotalSeconds;
long stopTime = (long)Math.Round(startTime + durationInStopwatchTicks);
telemetry.Stop(timestamp: stopTime);
if (Stopwatch.Frequency == TimeSpan.TicksPerSecond)
{
// In this case, the times should match exactly.
Assert.Equal(expectedDuration, telemetry.Duration);
}
else
{
// There will be a difference, but it should be less than
// 1 microsecond (10 ticks)
var difference = (telemetry.Duration - expectedDuration).Duration();
Assert.True(difference.Ticks < 10);
}
}
// telemetry implementation
protected DependencyTelemetry StartSendTelemetry(Message request, string method)
{
var soapAction = request.Headers.Action;
ClientOperation operation;
if (!this.ChannelManager.OperationMap.TryLookupByAction(soapAction, out operation))
{
return(null);
}
try
{
var telemetry = new DependencyTelemetry();
this.ChannelManager.TelemetryClient.Initialize(telemetry);
telemetry.Start();
telemetry.Type = DependencyConstants.WcfClientCall;
telemetry.Target = this.RemoteAddress.Uri.Host;
telemetry.Data = this.RemoteAddress.Uri.ToString();
telemetry.Name = operation.Name;
telemetry.Properties[DependencyConstants.SoapActionProperty] = soapAction;
if (operation.IsOneWay)
{
telemetry.Properties[DependencyConstants.IsOneWayProperty] = bool.TrueString;
}
this.SetCorrelationHeaders(telemetry, request);
return(telemetry);
}
catch (Exception ex)
{
WcfClientEventSource.Log.ClientTelemetryError(method, ex.ToString());
return(null);
}
}
/// <summary>
/// The function that needs to be called before sending a request to the server. Creates and initializes dependency telemetry item.
/// </summary>
/// <param name="telemetryClient">Telemetry client object to initialize the context of the telemetry item.</param>
internal static DependencyTelemetry BeginTracking(TelemetryClient telemetryClient)
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
Activity activity;
Activity currentActivity = Activity.Current;
// On .NET46 without profiler, outgoing requests are instrumented with reflection hook in DiagnosticSource
//// see https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/HttpHandlerDiagnosticListener.cs
// it creates an Activity and injects standard 'Request-Id' and 'Correlation-Context' headers itself, so we should not start Activity in this case
if (currentActivity != null && currentActivity.OperationName == "System.Net.Http.Desktop.HttpRequestOut")
{
activity = currentActivity;
}
else
{
// Every operation must have its own Activity
// if dependency is tracked with profiler of event source, we need to generate a proper Id for it
// in case of HTTP it will be propagated into the request header.
// So, we will create a new Activity for the dependency, just to generate an Id.
activity = new Activity(DependencyActivityName);
activity.Start();
}
// OperationCorrelationTelemetryInitializer will initialize telemetry as a child of current activity:
// But we need to initialize dependency telemetry from the current Activity:
// Activity was created for this dependency in the Http Desktop DiagnosticSource
if (activity.IdFormat == ActivityIdFormat.W3C)
{
var context = telemetry.Context;
context.Operation.Id = activity.TraceId.ToHexString();
if (activity.Parent != null || activity.ParentSpanId != default)
{
context.Operation.ParentId = activity.ParentSpanId.ToHexString();
}
telemetry.Id = activity.SpanId.ToHexString();
}
else
{
var context = telemetry.Context;
context.Operation.Id = activity.RootId;
context.Operation.ParentId = activity.ParentId;
telemetry.Id = activity.Id;
}
foreach (var item in activity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties.Add(item);
}
}
telemetryClient.Initialize(telemetry);
PretendProfilerIsAttached = false;
return(telemetry);
}
public void OperationTelemetryStartInitializesTimeStampAndStartTimeToTelemetry()
{
var telemetry = new DependencyTelemetry();
Assert.Equal(DateTimeOffset.MinValue, telemetry.Timestamp);
telemetry.Start();
Assert.NotEqual(DateTimeOffset.MinValue, telemetry.Timestamp);
}
/// <summary>
/// The function that needs to be called before sending a request to the server. Creates and initializes dependency telemetry item.
/// </summary>
/// <param name="telemetryClient">Telemetry client object to initialize the context of the telemetry item.</param>
internal static DependencyTelemetry BeginTracking(TelemetryClient telemetryClient)
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
telemetryClient.Initialize(telemetry);
#if NET45
Activity activity;
Activity currentActivity = Activity.Current;
// On .NET46 without profiler, outgoing requests are instrumented with reflection hook in DiagnosticSource
//// see https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/HttpHandlerDiagnosticListener.cs
// it creates an Activity and injects standard 'Request-Id' and 'Correlation-Context' headers itself, so we should not start Activity in this case
if (currentActivity != null && currentActivity.OperationName == "System.Net.Http.Desktop.HttpRequestOut")
{
activity = currentActivity;
}
else
{
// Every operation must have its own Activity
// if dependency is tracked with profiler of event source, we need to generate a proper hierarchical Id for it
// in case of HTTP it will be propagated into the requert header.
// So, we will create a new Activity for the dependency, jut to generate an Id.
activity = new Activity(DependencyActivityName);
// This is workaround for the issue https://github.com/Microsoft/ApplicationInsights-dotnet/issues/538
// if there is no parent Activity, ID Activity generates is not random enough to work well with
// ApplicationInsights sampling algorithm
// This code should go away when Activity is fixed: https://github.com/dotnet/corefx/issues/18418
if (Activity.Current == null)
{
activity.SetParentId(telemetry.Id);
}
//// end of workaround
activity.Start();
activity.Stop();
}
// telemetry is initialized from current Activity (root and parent Id, but not the Id)
telemetry.Id = activity.Id;
// set operation root Id in case there was no parent activity (e.g. HttpRequest in background thread)
if (string.IsNullOrEmpty(telemetry.Context.Operation.Id))
{
telemetry.Context.Operation.Id = activity.RootId;
}
#else
// telemetry is initialized by Base SDK OperationCorrealtionTelemetryInitializer
// however it does not know about Activity on .NET40 and does not know how to properly generate Ids
// let's fix it
telemetry.Id = ApplicationInsightsActivity.GenerateDependencyId(telemetry.Context.Operation.ParentId);
telemetry.Context.Operation.Id = ApplicationInsightsActivity.GetRootId(telemetry.Id);
#endif
PretendProfilerIsAttached = false;
return(telemetry);
}
/// <summary>
/// The function that needs to be called before sending a request to the server. Creates and initializes dependency telemetry item.
/// </summary>
/// <param name="telemetryClient">Telemetry client object to initialize the context of the telemetry item.</param>
internal static DependencyTelemetry BeginTracking(TelemetryClient telemetryClient)
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
telemetryClient.Initialize(telemetry);
PretendProfilerIsAttached = false;
return(telemetry);
}
public void OperationTelemetryStopComputesDurationAfterStart()
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
Thread.Sleep(2000);
Assert.Equal(TimeSpan.Zero, telemetry.Duration);
telemetry.Stop();
Assert.True(telemetry.Duration.TotalMilliseconds > 0);
}
public void OperationTelemetryStopDoesNotAffectTimeStampAndStartTimeAfterStart()
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
DateTimeOffset actualTime = telemetry.Timestamp;
telemetry.Stop();
Assert.Equal(telemetry.Timestamp, actualTime);
}
public void OperationTelemetryStopWithTimestampComputesDurationAfterStartWithTimestamp()
{
var telemetry = new DependencyTelemetry();
long startTime = 123456789012345L;
long ticksInOneSecond = Stopwatch.Frequency;
long stopTime = startTime + ticksInOneSecond;
telemetry.Start(timestamp: startTime);
telemetry.Stop(timestamp: stopTime);
Assert.Equal(TimeSpan.FromSeconds(1), telemetry.Duration);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[Queue("control-queue-ai", Connection = "ConnectionString")] IAsyncCollector <Context> contexts,
ILogger log)
{
log.LogInformation("Accept the request. Incoming request doesn't have correlation info.");
var requestActivity = new Activity("ActivitySpike: HttpTrigger Request");
var current = Activity.Current; // You can refer the current Activity. That is automatically created by HttpTrigger.
// No parent from the start
requestActivity.Start();
var requestTelemetry = new RequestTelemetry {
Name = "ActivitySpike: HttpTrigger Request"
};
requestTelemetry.SetActivity(requestActivity);
requestTelemetry.Start();
requestTelemetry.Stop();
client.Track(requestTelemetry);
var dependencyActivity = new Activity("HttpTrigger Dependency Queue output");
dependencyActivity.SetParentId(requestActivity.Id); // You can omit this code
dependencyActivity.Start();
var context = new Context()
{
ActivityId = dependencyActivity.Id,
ParentId = dependencyActivity.ParentId,
};
var dependencyTelemetry = new DependencyTelemetry {
Name = "ActivitySpike:: Enqueue"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
client.StartOperation(requestTelemetry);
await contexts.AddAsync(context);
dependencyActivity.Stop();
requestActivity.Stop();
dependencyTelemetry.Stop();
client.Track(dependencyTelemetry);
return(new OkObjectResult($"Orchestration has been started."));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[Queue("control-queue-ai", Connection = "ConnectionString")] IAsyncCollector <TraceContext> contexts,
ILogger log)
{
log.LogInformation("Accept the request. Incoming request doesn't have correlation info.");
var requestActivity = new Activity("W3CActivitySpike: HttpTrigger Request");
requestActivity.GenerateW3CContext();
// No parent from the start
requestActivity.Start();
var requestTelemetry = new RequestTelemetry {
Name = "W3CActivitySpike: HttpTrigger Request"
};
requestTelemetry.SetActivity(requestActivity);
requestTelemetry.Start();
requestTelemetry.Stop();
client.Track(requestTelemetry);
var dependencyActivity = new Activity("HttpTrigger Dependency Queue output");
dependencyActivity.SetTraceparent(requestActivity.GetTraceparent());
dependencyActivity.SetTracestate(requestActivity.GetTracestate());
// dependencyActivity.SetParentId(requestActivity.Id); // maybe not necessary
dependencyActivity.Start();
var context = dependencyActivity.CreateTraceContext();
var dependencyTelemetry = new DependencyTelemetry {
Name = "W3CActivitySpike:: Enqueue"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
await contexts.AddAsync(context);
dependencyActivity.Stop();
requestActivity.Stop();
dependencyTelemetry.Stop();
client.Track(dependencyTelemetry);
return(new OkObjectResult($"Orchestration has been started."));
}
/// <summary>
/// Create DependencyTelemetry from the Activity.
/// </summary>
/// <param name="context">TraceContext.</param>
/// <returns>DependencyTelemetry.</returns>
public static DependencyTelemetry CreateDependencyTelemetry(this TraceContextBase context)
{
var telemetry = new DependencyTelemetry {
Name = context.OperationName
};
telemetry.Start();
telemetry.Duration = context.Duration;
telemetry.Timestamp = context.StartTime; // TimeStamp is the time of ending the Activity.
telemetry.Id = context.TelemetryId;
telemetry.Context.Operation.Id = context.TelemetryContextOperationId;
telemetry.Context.Operation.ParentId = context.TelemetryContextOperationParentId;
return(telemetry);
}
public static async Task ActivityFunction([QueueTrigger("work-item-queue-ai", Connection = "ConnectionString")] Context context,
[Queue("control-queue-ai", Connection = "ConnectionString")] IAsyncCollector <Context> contexts,
ILogger log)
{
log.LogInformation($"Activity Functions Started.");
var requestActivity = new Activity("Activity Spike: Activity Function Request");
requestActivity.SetParentId(context.ActivityId);
requestActivity.Start();
var requestTelemetry = new RequestTelemetry {
Name = "Activity Spike: Activity Function Request"
};
requestTelemetry.SetActivity(requestActivity);
requestTelemetry.Start();
var dependencyActivity = new Activity("Activity FUnction Dependency");
dependencyActivity.SetParentId(requestActivity.Id); // You can omit this.
dependencyActivity.Start();
var dependencyTelemetry = new DependencyTelemetry {
Name = "Activity Spike: Activity Function Dependency"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
var c = new Context()
{
ActivityId = dependencyActivity.Id,
ParentId = dependencyActivity.ParentId,
OrchestrationActivity = context.OrchestrationActivity, // I skip the code for stack for the activity.
Completed = true
};
await contexts.AddAsync(c);
dependencyActivity.Stop();
dependencyTelemetry.Stop();
client.Track(dependencyTelemetry);
requestActivity.Stop();
requestTelemetry.Stop();
client.Track(requestTelemetry);
}
// telemetry implementation
private DependencyTelemetry StartOpenTelemetry(String method)
{
try
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
telemetry.Type = DependencyConstants.WcfChannelOpen;
telemetry.Target = RemoteAddress.Uri.Host;
telemetry.Data = RemoteAddress.Uri.ToString();
telemetry.Name = ChannelManager.OperationMap.ContractType.Name;
return(telemetry);
} catch (Exception ex)
{
WcfClientEventSource.Log.ClientTelemetryError(method, ex.ToString());
return(null);
}
}
public async Task Run([TimerTrigger("*/15 * * * * *")] TimerInfo myTimer)
{
var dep = new DependencyTelemetry()
{
Name = "Dependency Test",
Type = "Test",
Data = "C# Timer trigger function executed"
};
dep.Start();
await Task.Delay(3000);
dep.Stop();
_telemetryClient.TrackDependency(dep);
_logger.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
}
public static async Task ActivityFunction([QueueTrigger("work-item-queue-ai", Connection = "ConnectionString")] TraceContext traceContext,
[Queue("control-queue-ai", Connection = "ConnectionString")] IAsyncCollector <TraceContext> contexts,
ILogger log)
{
log.LogInformation($"W3CActivity Functions Started.");
var requestActivity = new Activity("W3CActivity Spike: Activity Function Request");
requestActivity.SetParentAndStart(traceContext);
var requestTelemetry = new RequestTelemetry {
Name = "W3CActivity Spike: Activity Function Request"
};
requestTelemetry.SetActivity(requestActivity);
requestTelemetry.Start();
var dependencyActivity = new Activity("W3CActivity FUnction Dependency");
dependencyActivity.SetParentAndStart(requestActivity);
var dependencyTelemetry = new DependencyTelemetry {
Name = "W3CActivity Spike: Activity Function Dependency"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
var c = dependencyActivity.CreateTraceContext();
c.OrchestrationContexts = traceContext.OrchestrationContexts;
c.Completed = true;
await contexts.AddAsync(c);
dependencyActivity.Stop();
dependencyTelemetry.Stop();
client.Track(dependencyTelemetry);
requestActivity.Stop();
requestTelemetry.Stop();
client.Track(requestTelemetry);
}
private static void InitializeTelemetry(DependencyTelemetry telemetry, Guid operationId, long timestamp)
{
telemetry.Start(timestamp);
var activity = Activity.Current;
if (activity != null)
{
// SQL Client does NOT create Activity.
// We initialize SQL dependency using Activity from incoming Request
// and it is the parent of the SQL dependency
if (activity.IdFormat == ActivityIdFormat.W3C)
{
var traceId = activity.TraceId.ToHexString();
telemetry.Context.Operation.Id = traceId;
telemetry.Context.Operation.ParentId = W3CUtilities.FormatTelemetryId(traceId, activity.SpanId.ToHexString());
}
else
{
telemetry.Context.Operation.Id = activity.RootId;
telemetry.Context.Operation.ParentId = activity.Id;
}
foreach (var item in activity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties[item.Key] = item.Value;
}
}
}
else
{
telemetry.Context.Operation.Id = operationId.ToStringInvariant("N");
}
}
private static void InitializeTelemetry(DependencyTelemetry telemetry, Guid operationId, long timestamp)
{
telemetry.Start(timestamp);
var activity = Activity.Current;
if (activity != null)
{
telemetry.Context.Operation.Id = activity.RootId;
telemetry.Context.Operation.ParentId = activity.ParentId;
foreach (var item in activity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties[item.Key] = item.Value;
}
}
}
else
{
telemetry.Context.Operation.Id = operationId.ToString("N");
}
}
/// <summary>
/// The function that needs to be called before sending a request to the server. Creates and initializes dependency telemetry item.
/// </summary>
/// <param name="telemetryClient">Telemetry client object to initialize the context of the telemetry item.</param>
internal static DependencyTelemetry BeginTracking(TelemetryClient telemetryClient)
{
var telemetry = new DependencyTelemetry();
telemetry.Start();
Activity activity;
Activity currentActivity = Activity.Current;
// On .NET46 without profiler, outgoing requests are instrumented with reflection hook in DiagnosticSource
//// see https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/HttpHandlerDiagnosticListener.cs
// it creates an Activity and injects standard 'Request-Id' and 'Correlation-Context' headers itself, so we should not start Activity in this case
if (currentActivity != null && currentActivity.OperationName == "System.Net.Http.Desktop.HttpRequestOut")
{
activity = currentActivity;
// OperationCorrelationTelemetryInitializer will initialize telemetry as a child of current activity:
// But we need to initialize dependency telemetry from the current Activity:
// Activity was created for this dependency in the Http Desktop DiagnosticSource
var context = telemetry.Context;
context.Operation.Id = activity.RootId;
context.Operation.ParentId = activity.ParentId;
foreach (var item in activity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties.Add(item);
}
}
telemetryClient.Initialize(telemetry);
}
else
{
telemetryClient.Initialize(telemetry);
// Every operation must have its own Activity
// if dependency is tracked with profiler of event source, we need to generate a proper Id for it
// in case of HTTP it will be propagated into the requert header.
// So, we will create a new Activity for the dependency, just to generate an Id.
activity = new Activity(DependencyActivityName);
// As a first step in supporting W3C protocol in ApplicationInsights,
// we want to generate Activity Ids in the W3C compatible format.
// While .NET changes to Activity are pending, we want to ensure trace starts with W3C compatible Id
// as early as possible, so that everyone has a chance to upgrade and have compatibility with W3C systems once they arrive.
// So if there is no parent Activity (i.e. this request has happened in the background, without parent scope), we'll override
// the current Activity with the one with properly formatted Id. This workaround should go away
// with W3C support on .NET https://github.com/dotnet/corefx/issues/30331 (TODO)
if (currentActivity == null)
{
activity.SetParentId(StringUtilities.GenerateTraceId());
}
// end of workaround
activity.Start();
}
// telemetry is initialized from current Activity (root and parent Id, but not the Id)
telemetry.Id = activity.Id;
// set operation root Id in case there was no parent activity (e.g. HttpRequest in background thread)
if (string.IsNullOrEmpty(telemetry.Context.Operation.Id))
{
telemetry.Context.Operation.Id = activity.RootId;
}
#pragma warning disable 612, 618
if (IsW3CEnabled)
{
W3COperationCorrelationTelemetryInitializer.UpdateTelemetry(telemetry, activity, true);
}
#pragma warning restore 612, 618
PretendProfilerIsAttached = false;
return(telemetry);
}
public static async Task Orchestrator([QueueTrigger("control-queue-ai", Connection = "ConnectionString")] Context context,
[Queue("work-item-queue-ai", Connection = "ConnectionString")] IAsyncCollector <Context> contexts,
ILogger log)
{
log.LogInformation($"Orchestration Started.");
Activity requestActivity = null;
if (context.OrchestrationActivity == null) // In case of the initial execution.
{
requestActivity = new Activity("Activity Spike: Orchestration Request");
requestActivity.SetParentId(context.ActivityId);
}
else
{
requestActivity = new Activity("Activity Spike: Orchestration Request");
// After Activity.SetParentId then Start the actvitiy, it will create a new Id. However, it is not Identical as the last execution.
// This is necessary. Or directly set from SubsetActivity. This is not recommended. However, there is no way for this protocol.
var property = typeof(Activity).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance);
property.SetValue(requestActivity, context.OrchestrationActivity.ActivityId);
requestActivity.SetParentId(context.OrchestrationActivity.ParentId);
}
requestActivity.Start();
var subsetActivity = new SubsetActivity()
{
ActivityId = requestActivity.Id,
ParentId = requestActivity.ParentId,
RootId = requestActivity.RootId
};
var requestTelemetry = new RequestTelemetry {
Name = "Activity Spike: Ochestration Result"
};
if (context.OrchestrationActivity == null)
{
requestTelemetry.SetActivity(requestActivity);
}
else
{
requestTelemetry.Id = context.OrchestrationActivity.ActivityId;
requestTelemetry.Context.Operation.Id = context.OrchestrationActivity.RootId;
requestTelemetry.Context.Operation.ParentId = context.OrchestrationActivity.ParentId;
}
requestTelemetry.Start();
// Only the last execution, we track it.
var dependencyActivity = new Activity("Activity Spike: Orchestration Dependency");
dependencyActivity.SetParentId(requestActivity.Id); // You can omit this.
dependencyActivity.Start();
var dependencyTelemetry = new DependencyTelemetry {
Name = "Activity Spike: Orchestration Dependency"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
var c = new Context()
{
ActivityId = requestActivity.Id,
ParentId = requestActivity.ParentId,
OrchestrationActivity = subsetActivity
};
dependencyActivity.Stop();
dependencyTelemetry.Stop();
if (context.Completed)
{
client.Track(dependencyTelemetry);
}
else
{
await contexts.AddAsync(c);
// We don't need to emit telemetry for intermediate execution.
}
requestActivity.Stop();
requestTelemetry.Stop();
if (context.OrchestrationActivity == null) // In case of the initial execution.
{
client.Track(requestTelemetry);
}
}
public static async Task Orchestrator([QueueTrigger("control-queue-ai", Connection = "ConnectionString")]
TraceContext traceContext,
[Queue("work-item-queue-ai", Connection = "ConnectionString")]
IAsyncCollector <TraceContext> contexts,
ILogger log)
{
log.LogInformation($"Orchestration Started.");
Activity requestActivity = null;
var isReplay = traceContext.OrchestrationContexts.Count != 0;
if (!isReplay)
{
requestActivity = new Activity("W3CActivity Spike: Orchestration Request");
requestActivity.SetParentAndStart(traceContext);
var requestTelemetry = new RequestTelemetry {
Name = "W3CActivity Spike: Orchestration Request"
};
requestTelemetry.SetActivity(requestActivity);
requestTelemetry.Start();
requestActivity.Stop();
requestTelemetry.Stop();
client.Track(requestTelemetry);
}
TraceContext c = null;
if (!isReplay)
{
c = requestActivity.CreateTraceContext();
c.OrchestrationContexts = traceContext.OrchestrationContexts;
c.OrchestrationContexts.Push(requestActivity.CreateTraceContext());
}
else
{
c = traceContext.OrchestrationContexts.Peek(); // if necessary. This program doesn't need it.
}
if (traceContext.Completed)
{
var dependencyActivity = new Activity("W3CActivity Spike: Orchestration Dependency");
dependencyActivity.SetParentAndStart(traceContext.OrchestrationContexts.Peek());
var dependencyTelemetry = new DependencyTelemetry {
Name = "W3CActivity Spike: Orchestration Dependency"
};
dependencyTelemetry.SetActivity(dependencyActivity);
dependencyTelemetry.Start();
dependencyActivity.Stop();
dependencyTelemetry.Stop();
client.Track(dependencyTelemetry);
}
else
{
await contexts.AddAsync(c);
// We don't need to emit telemetry for intermediate execution.
}
}
