public System.IDisposable CallExternalComponent(
System.Uri requestName,
string content)
{
Sample.Current.StartCallExternalComponent(
_processId,
_machineName,
requestName,
content
);
System.Diagnostics.Debug.WriteLine($"[Dependency] ERR: StartCallExternalComponent");
System.Diagnostics.Debug.WriteLine($"\t_processId:\t{_processId}");
System.Diagnostics.Debug.WriteLine($"\tEnvironment.MachineName:\t{Environment.MachineName}");
System.Diagnostics.Debug.WriteLine($"\trequestName.ToString():\t{requestName.ToString()}");
System.Diagnostics.Debug.WriteLine($"\tcontent:\t{content}");
_callExternalComponentStopwatch.Restart();
var callExternalComponentOperationHolder = _telemetryClient.StartOperation <DependencyTelemetry>(requestName.ToString());
callExternalComponentOperationHolder.Telemetry.Properties.Add("ProcessId", _processId.ToString());
callExternalComponentOperationHolder.Telemetry.Properties.Add("MachineName", Environment.MachineName);
callExternalComponentOperationHolder.Telemetry.Properties.Add("RequestName", requestName.ToString());
callExternalComponentOperationHolder.Telemetry.Properties.Add("Content", content);
return(new ScopeWrapper <DependencyTelemetry>(_telemetryClient, callExternalComponentOperationHolder, () => StopCallExternalComponent(requestName, content)));
}
public System.IDisposable RecieveActorMessage(
System.Uri requestUri,
string actorMethodName,
FG.ServiceFabric.Actors.Remoting.Runtime.ActorMessageHeaders actorMessageHeaders,
FG.ServiceFabric.Services.Remoting.FabricTransport.CustomServiceRequestHeader customServiceRequestHeader)
{
return(new ScopeWrapper(new IDisposable[]
{
ScopeWrapperWithAction.Wrap(() =>
{
PersonActorServiceEventSource.Current.StartRecieveActorMessage(
_actor,
requestUri,
actorMethodName,
actorMessageHeaders,
customServiceRequestHeader
);
return new ScopeWrapperWithAction(() =>
{
PersonActorServiceEventSource.Current.StopRecieveActorMessage(
_actor,
requestUri,
actorMethodName,
actorMessageHeaders,
customServiceRequestHeader
);
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
var recieveActorMessageOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>(requestUri.ToString() ?? "recieveActorMessage");
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ActorType", _actor.ActorType.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _actor.ApplicationTypeName);
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ApplicationName", _actor.ApplicationName);
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _actor.ServiceTypeName);
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ServiceName", _actor.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("PartitionId", _actor.PartitionId.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _actor.ReplicaOrInstanceId.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("NodeName", _actor.NodeName);
recieveActorMessageOperationHolder.Telemetry.Properties.Add("RequestUri", requestUri.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ActorMethodName", actorMethodName);
recieveActorMessageOperationHolder.Telemetry.Properties.Add("InterfaceId", (actorMessageHeaders?.InterfaceId ?? 0).ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("MethodId", (actorMessageHeaders?.MethodId ?? 0).ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("ActorId", actorMessageHeaders?.ActorId.ToString());
recieveActorMessageOperationHolder.Telemetry.Properties.Add("UserId", customServiceRequestHeader?.GetHeader("userId"));
recieveActorMessageOperationHolder.Telemetry.Properties.Add("CorrelationId", customServiceRequestHeader?.GetHeader("correlationId"));
return new ScopeWrapperWithAction(() =>
{
_telemetryClient.StopOperation <RequestTelemetry>(recieveActorMessageOperationHolder);
});
}),
}));
}
public System.IDisposable CallActor(
System.Uri requestUri,
string actorMethodName,
FG.ServiceFabric.Actors.Remoting.Runtime.ActorMessageHeaders actorMessageHeaders,
FG.ServiceFabric.Services.Remoting.FabricTransport.CustomServiceRequestHeader customServiceRequestHeader)
{
return(new ScopeWrapper(new IDisposable[]
{
ScopeWrapperWithAction.Wrap(() =>
{
WebApiServiceEventSource.Current.StartCallActor(
_context,
requestUri,
actorMethodName,
actorMessageHeaders,
customServiceRequestHeader
);
return new ScopeWrapperWithAction(() =>
{
WebApiServiceEventSource.Current.StopCallActor(
_context,
requestUri,
actorMethodName,
actorMessageHeaders,
customServiceRequestHeader
);
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
var callActorOperationHolder = _telemetryClient.StartOperation <DependencyTelemetry>(requestUri.ToString() ?? "callActor");
callActorOperationHolder.Telemetry.Properties.Add("ServiceName", _context.ServiceName.ToString());
callActorOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _context.ServiceTypeName);
callActorOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _context.InstanceId.ToString());
callActorOperationHolder.Telemetry.Properties.Add("PartitionId", _context.PartitionId.ToString());
callActorOperationHolder.Telemetry.Properties.Add("ApplicationName", _context.CodePackageActivationContext.ApplicationName);
callActorOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _context.CodePackageActivationContext.ApplicationTypeName);
callActorOperationHolder.Telemetry.Properties.Add("NodeName", _context.NodeContext.NodeName);
callActorOperationHolder.Telemetry.Properties.Add("RequestUri", requestUri.ToString());
callActorOperationHolder.Telemetry.Properties.Add("ActorMethodName", actorMethodName);
callActorOperationHolder.Telemetry.Properties.Add("InterfaceId", (actorMessageHeaders?.InterfaceId ?? 0).ToString());
callActorOperationHolder.Telemetry.Properties.Add("MethodId", (actorMessageHeaders?.MethodId ?? 0).ToString());
callActorOperationHolder.Telemetry.Properties.Add("ActorId", actorMessageHeaders?.ActorId.ToString());
callActorOperationHolder.Telemetry.Properties.Add("UserId", customServiceRequestHeader?.GetHeader("userId"));
callActorOperationHolder.Telemetry.Properties.Add("CorrelationId", customServiceRequestHeader?.GetHeader("correlationId"));
return new ScopeWrapperWithAction(() =>
{
_telemetryClient.StopOperation <DependencyTelemetry>(callActorOperationHolder);
});
}),
}));
}
public System.IDisposable RecieveServiceMessage(
System.Uri requestUri,
string serviceMethodName,
Microsoft.ServiceFabric.Services.Remoting.ServiceRemotingMessageHeaders serviceMessageHeaders,
FG.ServiceFabric.Services.Remoting.FabricTransport.CustomServiceRequestHeader customServiceRequestHeader)
{
return(new ScopeWrapper(new IDisposable[]
{
ScopeWrapperWithAction.Wrap(() =>
{
TitleActorServiceEventSource.Current.StartRecieveServiceMessage(
_context,
requestUri,
serviceMethodName,
serviceMessageHeaders,
customServiceRequestHeader
);
return new ScopeWrapperWithAction(() =>
{
TitleActorServiceEventSource.Current.StopRecieveServiceMessage(
_context,
requestUri,
serviceMethodName,
serviceMessageHeaders,
customServiceRequestHeader
);
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
var recieveServiceMessageOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>(requestUri.ToString() ?? "recieveServiceMessage");
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ServiceName", _context.ServiceName.ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _context.ServiceTypeName);
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _context.ReplicaOrInstanceId.ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("PartitionId", _context.PartitionId.ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ApplicationName", _context.CodePackageActivationContext.ApplicationName);
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _context.CodePackageActivationContext.ApplicationTypeName);
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("NodeName", _context.NodeContext.NodeName);
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("RequestUri", requestUri.ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("ServiceMethodName", serviceMethodName);
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("InterfaceId", (serviceMessageHeaders?.InterfaceId ?? 0).ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("MethodId", (serviceMessageHeaders?.MethodId ?? 0).ToString());
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("UserId", customServiceRequestHeader?.GetHeader("userId"));
recieveServiceMessageOperationHolder.Telemetry.Properties.Add("CorrelationId", customServiceRequestHeader?.GetHeader("correlationId"));
return new ScopeWrapperWithAction(() =>
{
_telemetryClient.StopOperation <RequestTelemetry>(recieveServiceMessageOperationHolder);
});
}),
}));
}
public void StartGetAll(
)
{
WebApiServiceEventSource.Current.StartGetAll(
_context
);
var getAllOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("getAll");
getAllOperationHolder.Telemetry.Properties.Add("ServiceName", _context.ServiceName.ToString());
getAllOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _context.ServiceTypeName);
getAllOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _context.InstanceId.ToString());
getAllOperationHolder.Telemetry.Properties.Add("PartitionId", _context.PartitionId.ToString());
getAllOperationHolder.Telemetry.Properties.Add("ApplicationName", _context.CodePackageActivationContext.ApplicationName);
getAllOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _context.CodePackageActivationContext.ApplicationTypeName);
getAllOperationHolder.Telemetry.Properties.Add("NodeName", _context.NodeContext.NodeName);
OperationHolder.StartOperation(getAllOperationHolder);
}
public void AppInsightsUsesActivityWhenDiagnosticSourceIsAvailableW3C()
{
// Regular use case - System.DiagnosticSource is available. Regular unit test can cover this scenario.
var config = new TelemetryConfiguration();
config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
var tc = new TelemetryClient(config);
using (var requestOperation = tc.StartOperation <RequestTelemetry>("request", "guid"))
{
using (var dependencyOperation = tc.StartOperation <DependencyTelemetry>("dependency", "guid"))
{
// "guid" is not w3c compatible. Ignored
Assert.IsFalse(dependencyOperation.Telemetry.Id.StartsWith("|guid."));
// but "guid" will be stored in custom properties
Assert.AreEqual("guid", dependencyOperation.Telemetry.Properties["ai_legacyRootId"]);
tc.TrackTrace("Hello World!");
}
}
}
public void StartActorActive(
bool firstActivation)
{
PersonActorServiceEventSource.Current.StartActorActive(
_actor,
firstActivation
);
var actorActiveOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("actorActive");
actorActiveOperationHolder.Telemetry.Properties.Add("ActorType", _actor.ActorType.ToString());
actorActiveOperationHolder.Telemetry.Properties.Add("ActorId", _actor.ActorId.ToString());
actorActiveOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _actor.ApplicationTypeName);
actorActiveOperationHolder.Telemetry.Properties.Add("ApplicationName", _actor.ApplicationName);
actorActiveOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _actor.ServiceTypeName);
actorActiveOperationHolder.Telemetry.Properties.Add("ServiceName", _actor.ToString());
actorActiveOperationHolder.Telemetry.Properties.Add("PartitionId", _actor.PartitionId.ToString());
actorActiveOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _actor.ReplicaOrInstanceId.ToString());
actorActiveOperationHolder.Telemetry.Properties.Add("NodeName", _actor.NodeName);
actorActiveOperationHolder.Telemetry.Properties.Add("FirstActivation", firstActivation.ToString());
OperationHolder.StartOperation(actorActiveOperationHolder);
}
public void StartLoop(
)
{
DefaultEventSource.Current.StartLoop(
_processId,
_machineName,
_actorId
);
_loopOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("loop");
_loopOperationHolder.Telemetry.Properties.Add("ProcessId", _processId.ToString());
_loopOperationHolder.Telemetry.Properties.Add("MachineName", Environment.MachineName);
_loopOperationHolder.Telemetry.Properties.Add("Actor", _actorId.ToString());
}
public void AppInsightsUsesActivityWhenDiagnosticSourceIsAvailableNonW3C()
{
try
{
// Regular use case - System.DiagnosticSource is available. Regular unit test can cover this scenario.
var config = new TelemetryConfiguration();
DisableW3CFormatInActivity();
config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
var tc = new TelemetryClient(config);
using (var requestOperation = tc.StartOperation <RequestTelemetry>("request", "guid"))
{
using (var dependencyOperation = tc.StartOperation <DependencyTelemetry>("dependency", "guid"))
{
Assert.IsTrue(dependencyOperation.Telemetry.Id.StartsWith("|guid."));
tc.TrackTrace("Hello World!");
}
}
}
finally
{
EnableW3CFormatInActivity();
}
}
public void StartLoop(
)
{
Sample.Current.StartLoop(
);
System.Diagnostics.Debug.WriteLine($"[ConsoleRunner] ERR: StartLoop");
_loopStopwatch.Restart();
var loopOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("loop");
OperationHolder.StartOperation(loopOperationHolder);
}
public void StartHello(
)
{
Sample.Current.StartHello(
);
System.Diagnostics.Debug.WriteLine($"[Console] ERR: StartHello");
_helloStopwatch.Restart();
var helloOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("hello");
OperationHolder.StartOperation(helloOperationHolder);
}
public void StartActorMessageRecieved(
string methodName,
CodeEffect.ServiceFabric.Services.Remoting.FabricTransport.CustomServiceRequestHeader headers)
{
WebApiServiceEventSource.Current.StartActorMessageRecieved(
_context,
methodName,
headers
);
var actorMessageRecievedOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("actorMessageRecieved");
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("ServiceName", _context.ServiceName.ToString());
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _context.ServiceTypeName);
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _context.InstanceId.ToString());
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("PartitionId", _context.PartitionId.ToString());
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("ApplicationName", _context.CodePackageActivationContext.ApplicationName);
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _context.CodePackageActivationContext.ApplicationTypeName);
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("NodeName", _context.NodeContext.NodeName);
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("MethodName", methodName);
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("User", headers?.GetHeader("name"));
actorMessageRecievedOperationHolder.Telemetry.Properties.Add("CorrelationId", headers?.GetHeader("correlation-id"));
OperationHolder.StartOperation(actorMessageRecievedOperationHolder);
}
public System.IDisposable RunAsyncLoop(
)
{
return(new ScopeWrapper(new IDisposable[]
{
ScopeWrapperWithAction.Wrap(() =>
{
PersonActorServiceEventSource.Current.StartRunAsyncLoop(
_actorService,
_context
);
return new ScopeWrapperWithAction(() =>
{
PersonActorServiceEventSource.Current.StopRunAsyncLoop(
_actorService,
_context
);
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
var runAsyncLoopOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>(FG.ServiceFabric.Services.Remoting.FabricTransport.ServiceRequestContext.Current?["requestUri"] ?? "runAsyncLoop");
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ActorType", _actorService.ActorTypeInformation.ImplementationType.ToString());
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _actorService.Context.CodePackageActivationContext.ApplicationTypeName);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ApplicationName", _actorService.Context.CodePackageActivationContext.ApplicationName);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _actorService.Context.ServiceTypeName);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ServiceName", _actorService.Context.ServiceName.ToString());
runAsyncLoopOperationHolder.Telemetry.Properties.Add("PartitionId", _actorService.Context.PartitionId.ToString());
runAsyncLoopOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _actorService.Context.ReplicaId.ToString());
runAsyncLoopOperationHolder.Telemetry.Properties.Add("NodeName", _actorService.Context.NodeContext.NodeName);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("CorrelationId", FG.ServiceFabric.Services.Remoting.FabricTransport.ServiceRequestContext.Current?["correlationId"]);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("UserId", FG.ServiceFabric.Services.Remoting.FabricTransport.ServiceRequestContext.Current?["userId"]);
runAsyncLoopOperationHolder.Telemetry.Properties.Add("RequestUri", FG.ServiceFabric.Services.Remoting.FabricTransport.ServiceRequestContext.Current?["requestUri"]);
return new ScopeWrapperWithAction(() =>
{
_telemetryClient.StopOperation <RequestTelemetry>(runAsyncLoopOperationHolder);
});
}),
}));
}
public void StartLoop(
)
{
FGDiagnosticsAutoLoggerSamplesConsoleApplication1EventSource.Current.StartLoop(
_autogenerated,
_machineName
);
System.Diagnostics.Debug.WriteLine($"[ConsoleRunner] ERR: StartLoop");
System.Diagnostics.Debug.WriteLine($"\t_autogenerated:\t{_autogenerated}");
System.Diagnostics.Debug.WriteLine($"\tEnvironment.MachineName:\t{Environment.MachineName}");
_loopStopwatch.Restart();
var loopOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("loop");
loopOperationHolder.Telemetry.Properties.Add("Autogenerated", _autogenerated.ToString());
loopOperationHolder.Telemetry.Properties.Add("MachineName", Environment.MachineName);
OperationHolder.StartOperation(loopOperationHolder);
}
public void StartRunAsyncLoop(
int iteration,
System.Guid correlationId)
{
DefaultEventSource.Current.StartRunAsyncLoop(
_context,
iteration,
correlationId
);
_runAsyncLoopOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("runAsyncLoop");
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("ServiceName", _context.ServiceName.ToString());
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("ServiceTypeName", _context.ServiceTypeName);
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("ReplicaOrInstanceId", _context.GetReplicaOrInstanceId().ToString());
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("PartitionId", _context.PartitionId.ToString());
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("ApplicationName", _context.CodePackageActivationContext.ApplicationName);
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("ApplicationTypeName", _context.CodePackageActivationContext.ApplicationTypeName);
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("NodeName", _context.NodeContext.NodeName);
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("Iteration", iteration.ToString());
_runAsyncLoopOperationHolder.Telemetry.Properties.Add("CorrelationId", correlationId.ToString());
}
public void StartHello(
)
{
Sample.Current.StartHello(
_actorId,
_processId,
_machineName
);
System.Diagnostics.Debug.WriteLine($"[Console] ERR: StartHello");
System.Diagnostics.Debug.WriteLine($"\t_actorId.ToString():\t{_actorId.ToString()}");
System.Diagnostics.Debug.WriteLine($"\t_actorId.Kind.ToString():\t{_actorId.Kind.ToString()}");
System.Diagnostics.Debug.WriteLine($"\t_processId:\t{_processId}");
System.Diagnostics.Debug.WriteLine($"\tEnvironment.MachineName:\t{Environment.MachineName}");
_helloStopwatch.Restart();
var helloOperationHolder = _telemetryClient.StartOperation <RequestTelemetry>("hello");
helloOperationHolder.Telemetry.Properties.Add("ActorId", _actorId.ToString());
helloOperationHolder.Telemetry.Properties.Add("ActorIdType", _actorId.Kind.ToString());
helloOperationHolder.Telemetry.Properties.Add("ProcessId", _processId.ToString());
helloOperationHolder.Telemetry.Properties.Add("MachineName", Environment.MachineName);
OperationHolder.StartOperation(helloOperationHolder);
}
public void StartDependencyTrackingThrowsExceptionWithNullTelemetryClient()
{
TelemetryClient tc = null;
tc.StartOperation <DependencyTelemetry>(null);
}
// Create a CSV file and save to Blob storage with the Headers required for our Azure Function processing
// A new request telemetry is created
// The request is part of the parent request (since)
public void CreateBlob(string fileName)
{
///////////////////////////////////////////////////
// Grab existing
///////////////////////////////////////////////////
Microsoft.ApplicationInsights.TelemetryClient telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
telemetryClient.Context.User.AuthenticatedUserId = "*****@*****.**";
string traceoperation = null;
string traceparent = null;
System.Console.WriteLine("telemetryClient.Context.Operation.Id: " + telemetryClient.Context.Operation.Id);
System.Console.WriteLine("telemetryClient.Context.Session.Id: " + telemetryClient.Context.Session.Id);
System.Console.WriteLine("telemetryClient.Context.Operation.ParentId: " + telemetryClient.Context.Operation.ParentId);
Microsoft.ApplicationInsights.DataContracts.RequestTelemetry requestTelemetry = new Microsoft.ApplicationInsights.DataContracts.RequestTelemetry();
requestTelemetry.Name = "Create Blob: " + fileName;
//requestTelemetry.Source = requestContext.Replace("appId=",string.Empty);
requestTelemetry.Timestamp = System.DateTimeOffset.Now;
requestTelemetry.Context.Operation.Id = traceoperation;
requestTelemetry.Context.Operation.ParentId = traceparent;
requestTelemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
using (var requestBlock = telemetryClient.StartOperation<Microsoft.ApplicationInsights.DataContracts.RequestTelemetry>(requestTelemetry))
{
///////////////////////////////////////////////////
// Request Telemetry
///////////////////////////////////////////////////
requestBlock.Telemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
if (!string.IsNullOrWhiteSpace(traceoperation))
{
// Use the existing common operation id
requestBlock.Telemetry.Context.Operation.Id = traceoperation;
System.Console.WriteLine("[Use existing] traceoperation: " + traceoperation);
}
else
{
// Set the traceoperation (we did not know it until now)
traceoperation = requestBlock.Telemetry.Context.Operation.Id;
System.Console.WriteLine("[Set the] traceoperation = requestBlock.Telemetry.Context.Operation.Id: " + traceoperation);
}
if (!string.IsNullOrWhiteSpace(traceparent))
{
// Use the existing traceparent
requestBlock.Telemetry.Context.Operation.ParentId = traceparent;
System.Console.WriteLine("[Use existing] traceparent: " + traceparent);
}
else
{
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("[Set the] traceparent = requestBlock.Telemetry.Id: " + traceparent);
}
// Store future parent id
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("traceparent = requestBlock.Telemetry.Id: " + traceparent);
///////////////////////////////////////////////////
// Create Dependency for future Azure Function processing
// NOTE: I trick it by giving a Start Time Offset of Now.AddSeconds(1), so it sorts correctly in the Azure Portal UI
///////////////////////////////////////////////////
string operationName = "Dependency: Blob Event";
// Set the target so it points to the "dependent" app insights account app id
// string target = "03-disttrace-func-blob | cid-v1:676560d0-81fb-4e5b-bfdd-7da1ad11c866"
string target = "03-disttrace-func-blob | cid-v1:" + System.Environment.GetEnvironmentVariable("ai_03_disttrace_web_app_appkey");
string dependencyName = "Dependency Name: Azure Function Blob Trigger";
Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry dependencyTelemetry =
new Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry(
operationName, target, dependencyName,
"02-disttrace-web-app", System.DateTimeOffset.Now.AddSeconds(1), System.TimeSpan.FromSeconds(2), "200", true);
dependencyTelemetry.Context.Operation.Id = traceoperation;
dependencyTelemetry.Context.Operation.ParentId = requestBlock.Telemetry.Id;
// Store future parent id
traceparent = dependencyTelemetry.Id;
System.Console.WriteLine("traceparent = dependencyTelemetry.Id: " + traceparent);
telemetryClient.TrackDependency(dependencyTelemetry);
///////////////////////////////////////////////////
// Blob code
///////////////////////////////////////////////////
string containerName = "appinsightstest";
string storageConnectionString = System.Environment.GetEnvironmentVariable("ai_storage_key");
CloudStorageAccount storageAccount = null;
System.Console.WriteLine("storageConnectionString: " + storageConnectionString);
CloudStorageAccount.TryParse(storageConnectionString, out storageAccount);
System.Collections.Generic.List<string> list = new System.Collections.Generic.List<string>();
list.Add("id,date");
for (int i = 1; i <= 50000; i++)
{
list.Add(i.ToString() + "," + string.Format("{0:MM/dd/yyyy}", System.DateTime.Now));
}
var text = string.Join("\n", list.ToArray());
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
blobStorage.DefaultRequestOptions.RetryPolicy = new Microsoft.WindowsAzure.Storage.RetryPolicies.LinearRetry(System.TimeSpan.FromSeconds(1), 10);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobStorage.GetContainerReference(containerName);
container.CreateIfNotExistsAsync().Wait();
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob = container.GetBlockBlobReference(fileName);
///////////////////////////////////////////////////
// Set the blob's meta data
// We need the values from the dependency
///////////////////////////////////////////////////
// Request-Context: appId=cid-v1:{The App Id of the current App Insights Account}
string requestContext = "appId=cid-v1:" + System.Environment.GetEnvironmentVariable("ai_02_disttrace_web_app_appkey");
System.Console.WriteLine("Blob Metadata -> requestContext: " + requestContext);
blob.Metadata.Add("RequestContext", requestContext);
// Request-Id / traceparent: {parent request/operation id} (e.g. the Track Dependency)
System.Console.WriteLine("Blob Metadata -> RequestId: " + traceparent);
blob.Metadata.Add("RequestId", traceparent);
System.Console.WriteLine("Blob Metadata -> traceparent: " + traceparent);
blob.Metadata.Add("traceparent", traceparent);
// Traceoperation {common operation id} (e.g. same operation id for all requests in this telemetry pipeline)
System.Console.WriteLine("Blob Metadata -> traceoperation: " + traceoperation);
blob.Metadata.Add("traceoperation", traceoperation);
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(text)))
{
blob.UploadFromStreamAsync(memoryStream).Wait();
}
requestTelemetry.ResponseCode = "200";
requestTelemetry.Success = true;
telemetryClient.StopOperation(requestBlock);
} // using
///////////////////////////////////////////////////
// For Debugging
///////////////////////////////////////////////////
telemetryClient.Flush();
} // Create Blob
public System.IDisposable CallExternalComponent(
System.Uri requestName,
string content)
{
return(new ScopeWrapper(new IDisposable[]
{
ScopeWrapperWithAction.Wrap(() =>
{
FGDiagnosticsAutoLoggerSamplesConsoleApplication1EventSource.Current.StartCallExternalComponent(
_autogenerated,
_machineName,
requestName,
content
);
return new ScopeWrapperWithAction(() =>
{
FGDiagnosticsAutoLoggerSamplesConsoleApplication1EventSource.Current.StopCallExternalComponent(
_autogenerated,
_machineName,
requestName,
content
);
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
System.Diagnostics.Debug.WriteLine($"[Dependency] ERR: StartCallExternalComponent");
System.Diagnostics.Debug.WriteLine($"\t_autogenerated:\t{_autogenerated}");
System.Diagnostics.Debug.WriteLine($"\tEnvironment.MachineName:\t{Environment.MachineName}");
System.Diagnostics.Debug.WriteLine($"\trequestName.ToString():\t{requestName.ToString()}");
System.Diagnostics.Debug.WriteLine($"\tcontent:\t{content}");
return new ScopeWrapperWithAction(() =>
{
System.Diagnostics.Debug.WriteLine($"[Dependency] ERR: StopCallExternalComponent");
System.Diagnostics.Debug.WriteLine($"\t_autogenerated:\t{_autogenerated}");
System.Diagnostics.Debug.WriteLine($"\tEnvironment.MachineName:\t{Environment.MachineName}");
System.Diagnostics.Debug.WriteLine($"\trequestName.ToString():\t{requestName.ToString()}");
System.Diagnostics.Debug.WriteLine($"\tcontent:\t{content}");
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
_callExternalComponentStopwatch.Restart();
return new ScopeWrapperWithAction(() =>
{
_callExternalComponentStopwatch.Stop();
});
}),
ScopeWrapperWithAction.Wrap(() =>
{
var callExternalComponentOperationHolder = _telemetryClient.StartOperation <DependencyTelemetry>(requestName.ToString() ?? "callExternalComponent");
callExternalComponentOperationHolder.Telemetry.Properties.Add("Autogenerated", _autogenerated.ToString());
callExternalComponentOperationHolder.Telemetry.Properties.Add("MachineName", Environment.MachineName);
callExternalComponentOperationHolder.Telemetry.Properties.Add("RequestName", requestName.ToString());
callExternalComponentOperationHolder.Telemetry.Properties.Add("Content", content);
return new ScopeWrapperWithAction(() =>
{
_telemetryClient.StopOperation <DependencyTelemetry>(callExternalComponentOperationHolder);
});
}),
}));
}
