internal static object Run()
{
Console.WriteLine("Hello World!");
var collector = new DependenciesCollector(new DependenciesCollectorOptions(), tracer, Samplers.AlwaysSample);
var exporter = new ZipkinTraceExporter(
new ZipkinTraceExporterOptions()
{
Endpoint = new Uri("https://zipkin.azurewebsites.net/api/v2/spans"),
ServiceName = typeof(Program).Assembly.GetName().Name,
},
Tracing.ExportComponent);
exporter.Start();
var scope = tracer.SpanBuilder("incoming request").SetSampler(Samplers.AlwaysSample).StartScopedSpan();
//Thread.Sleep(TimeSpan.FromSeconds(1));
HttpClient client = new HttpClient();
var t = client.GetStringAsync("http://bing.com");
t.Wait();
scope.Dispose();
Console.ReadLine();
return(null);
}
public async Task HttpDepenenciesCollectorInjectsHeadersAsync()
{
var startEndHandler = new Mock <IStartEndHandler>();
var serverLifeTime = TestServer.RunServer(
(ctx) =>
{
ctx.Response.StatusCode = 200;
ctx.Response.OutputStream.Close();
},
out string host,
out int port);
var url = $"http://{host}:{port}/";
ITraceId expectedTraceId = TraceId.Invalid;
ISpanId expectedSpanId = SpanId.Invalid;
using (serverLifeTime)
{
var tracer = new Tracer(new RandomGenerator(), startEndHandler.Object, new DateTimeOffsetClock(), new TraceConfig());
var tf = new Mock <ITextFormat>();
tf
.Setup(m => m.Inject <HttpRequestMessage>(It.IsAny <ISpanContext>(), It.IsAny <HttpRequestMessage>(), It.IsAny <Action <HttpRequestMessage, string, string> >()))
.Callback((ISpanContext sc, HttpRequestMessage obj, Action <HttpRequestMessage, string, string> setter) =>
{
expectedTraceId = sc.TraceId;
expectedSpanId = sc.SpanId;
});
var propagationComponent = new Mock <IPropagationComponent>();
propagationComponent.SetupGet(m => m.TextFormat).Returns(tf.Object);
using (var dc = new DependenciesCollector(new DependenciesCollectorOptions(), tracer, Samplers.AlwaysSample, propagationComponent.Object))
{
using (var c = new HttpClient())
{
var request = new HttpRequestMessage
{
RequestUri = new Uri(url),
Method = new HttpMethod("GET"),
};
await c.SendAsync(request);
}
}
}
Assert.Equal(2, startEndHandler.Invocations.Count); // begin and end was called
var spanData = ((Span)startEndHandler.Invocations[1].Arguments[0]).ToSpanData();
Assert.Equal(expectedTraceId, spanData.Context.TraceId);
Assert.Equal(expectedSpanId, spanData.Context.SpanId);
}
public static void Main(string[] args)
{
// Enable distributed tracing
string instrumentationKey = Environment.GetEnvironmentVariable("AZURE_INSTRUMENTATION_KEY");
new ApplicationInsightsExporter(Tracing.SpanExporter, Stats.ViewManager, new TelemetryConfiguration(instrumentationKey)).Start();
using var dependencies = new DependenciesCollector(new DependenciesCollectorOptions(), Tracing.Tracer, Samplers.AlwaysSample);
using var requests = new RequestsCollector(new RequestsCollectorOptions(), Tracing.Tracer, Samplers.AlwaysSample);
CreateWebHostBuilder(args).Build().Run();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddOpenTelemetry(() =>
{
var tracerFactory = new LoggingTracerFactory();
var tracer = tracerFactory.GetTracer("ServerApp", "semver:1.0.0");
var dependenciesCollector = new DependenciesCollector(tracerFactory);
var aspNetCoreCollector = new AspNetCoreCollector(tracer);
return(tracerFactory);
});
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false)
.Build();
// Enable distributed tracing
string instrumentationKey = config["AZURE_INSTRUMENTATION_KEY"];
new ApplicationInsightsExporter(Tracing.SpanExporter, Stats.ViewManager, new TelemetryConfiguration(instrumentationKey)).Start();
using var dependencies = new DependenciesCollector(new DependenciesCollectorOptions(), Tracing.Tracer, Samplers.AlwaysSample);
using var requests = new RequestsCollector(new RequestsCollectorOptions(), Tracing.Tracer, Samplers.AlwaysSample);
CreateWebHostBuilder(args).Build().Run();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddOpenTelemetry((svcProvider, tracerBuilder) =>
{
// Make the logger factory available to the dependency injection
// container so that it may be injected into the OpenTelemetry Tracer.
var loggerFactory = svcProvider.GetRequiredService <ILoggerFactory>();
// Adds the New Relic Exporter loading settings from the appsettings.json
var tracerFactory = TracerFactory.Create(b => b.UseNewRelic(Configuration, loggerFactory)
.SetSampler(Samplers.AlwaysSample));
var dependenciesCollector = new DependenciesCollector(new HttpClientCollectorOptions(), tracerFactory);
var aspNetCoreCollector = new AspNetCoreCollector(tracerFactory.GetTracer(null));
});
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
// Obtain the API Key from the Web.Config file
var apiKey = ConfigurationManager.AppSettings["NewRelic.Telemetry.ApiKey"];
// Create the tracer factory registering New Relic as the Data Exporter
var tracerFactory = TracerFactory.Create((b) =>
{
b.UseNewRelic(apiKey)
.AddDependencyCollector()
.SetSampler(Samplers.AlwaysSample);
});
var dependenciesCollector = new DependenciesCollector(new HttpClientCollectorOptions(), tracerFactory);
// Make the tracer available to the application
OTTracer = tracerFactory.GetTracer("SampleAspNetFrameworkApp");
}
/// <summary>
/// Collects all references of an asset dynamically.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="assetResolver">The asset resolver.</param>
/// <param name="isRecursive">if set to <c>true</c> collects references recursively.</param>
/// <param name="keepParents">Indicate if the parent of the provided <paramref name="result"/> should be kept or not</param>
/// <exception cref="System.ArgumentNullException">
/// result
/// or
/// assetResolver
/// </exception>
private static void CollectDynamicOutReferences(AssetDependencies result, Func <AssetId, AssetItem> assetResolver, bool isRecursive, bool keepParents)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (assetResolver == null)
{
throw new ArgumentNullException(nameof(assetResolver));
}
var addedReferences = new HashSet <AssetId>();
var itemsToAnalyze = new Queue <AssetItem>();
var referenceCollector = new DependenciesCollector();
// Reset the dependencies/parts.
result.Reset(keepParents);
var assetItem = result.Item;
// marked as processed to not add it again
addedReferences.Add(assetItem.Id);
itemsToAnalyze.Enqueue(assetItem);
while (itemsToAnalyze.Count > 0)
{
var item = itemsToAnalyze.Dequeue();
foreach (var link in referenceCollector.GetDependencies(item))
{
if (addedReferences.Contains(link.Element.Id))
{
continue;
}
// marked as processed to not add it again
addedReferences.Add(link.Element.Id);
// add the location to the reference location list
var nextItem = assetResolver(link.Element.Id);
if (nextItem != null)
{
result.AddLinkOut(nextItem, link.Type);
// add current element to analyze list, to analyze dependencies recursively
if (isRecursive)
{
itemsToAnalyze.Enqueue(nextItem);
}
}
else
{
result.AddBrokenLinkOut(link);
}
}
if (!isRecursive)
{
break;
}
}
}
public async Task HttpOutCallsAreCollectedSuccesfullyAsync(HttpOutTestCase tc)
{
var serverLifeTime = TestServer.RunServer(
(ctx) =>
{
ctx.Response.StatusCode = tc.responseCode == 0 ? 200 : tc.responseCode;
ctx.Response.OutputStream.Close();
},
out string host,
out int port);
var startEndHandler = new Mock <IStartEndHandler>();
var tracer = new Tracer(new RandomGenerator(), startEndHandler.Object, new TraceConfig(), null);
tc.url = NormaizeValues(tc.url, host, port);
using (serverLifeTime)
{
using (var dc = new DependenciesCollector(new DependenciesCollectorOptions(), tracer, Samplers.AlwaysSample))
{
try
{
using (var c = new HttpClient())
{
var request = new HttpRequestMessage
{
RequestUri = new Uri(tc.url),
Method = new HttpMethod(tc.method),
};
if (tc.headers != null)
{
foreach (var header in tc.headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
await c.SendAsync(request);
}
}
catch (Exception)
{
//test case can intentiaonlly send request that will result in exception
}
}
}
Assert.Equal(2, startEndHandler.Invocations.Count); // begin and end was called
var spanData = ((Span)startEndHandler.Invocations[1].Arguments[0]).ToSpanData();
Assert.Equal(tc.spanName, spanData.Name);
Assert.Equal(tc.spanKind, spanData.Kind.ToString());
var d = new Dictionary <CanonicalCode, string>()
{
{ CanonicalCode.Ok, "OK" },
{ CanonicalCode.Cancelled, "CANCELLED" },
{ CanonicalCode.Unknown, "UNKNOWN" },
{ CanonicalCode.InvalidArgument, "INVALID_ARGUMENT" },
{ CanonicalCode.DeadlineExceeded, "DEADLINE_EXCEEDED" },
{ CanonicalCode.NotFound, "NOT_FOUND" },
{ CanonicalCode.AlreadyExists, "ALREADY_EXISTS" },
{ CanonicalCode.PermissionDenied, "PERMISSION_DENIED" },
{ CanonicalCode.ResourceExhausted, "RESOURCE_EXHAUSTED" },
{ CanonicalCode.FailedPrecondition, "FAILED_PRECONDITION" },
{ CanonicalCode.Aborted, "ABORTED" },
{ CanonicalCode.OutOfRange, "OUT_OF_RANGE" },
{ CanonicalCode.Unimplemented, "UNIMPLEMENTED" },
{ CanonicalCode.Internal, "INTERNAL" },
{ CanonicalCode.Unavailable, "UNAVAILABLE" },
{ CanonicalCode.DataLoss, "DATA_LOSS" },
{ CanonicalCode.Unauthenticated, "UNAUTHENTICATED" },
};
Assert.Equal(tc.spanStatus, d[spanData.Status.CanonicalCode]);
var normilizedAttributes = spanData.Attributes.AttributeMap.ToDictionary(x => x.Key, x => AttributeToSimpleString(x.Value));
tc.spanAttributes = tc.spanAttributes.ToDictionary(x => x.Key, x => NormaizeValues(x.Value, host, port));
Assert.Equal(tc.spanAttributes.ToHashSet(), normilizedAttributes.ToHashSet());
}
/// <summary>
/// Collects all references of an asset dynamically.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="assetResolver">The asset resolver.</param>
/// <param name="isRecursive">if set to <c>true</c> collects references recursively.</param>
/// <param name="keepParents">Indicate if the parent of the provided <paramref name="result"/> should be kept or not</param>
/// <exception cref="System.ArgumentNullException">
/// result
/// or
/// assetResolver
/// </exception>
private static void CollectDynamicOutReferences(AssetDependencies result, Func<Guid, AssetItem> assetResolver, bool isRecursive, bool keepParents)
{
if (result == null) throw new ArgumentNullException("result");
if (assetResolver == null) throw new ArgumentNullException("assetResolver");
var addedReferences = new HashSet<Guid>();
var itemsToAnalyze = new Queue<AssetItem>();
var referenceCollector = new DependenciesCollector();
result.Reset(keepParents);
var assetItem = result.Item;
// marked as processed to not add it again
addedReferences.Add(assetItem.Id);
itemsToAnalyze.Enqueue(assetItem);
while (itemsToAnalyze.Count > 0)
{
var item = itemsToAnalyze.Dequeue();
foreach (var link in referenceCollector.GetDependencies(item))
{
if (addedReferences.Contains(link.Element.Id))
continue;
// marked as processed to not add it again
addedReferences.Add(link.Element.Id);
// add the location to the reference location list
var nextItem = assetResolver(link.Element.Id);
if (nextItem != null)
{
result.AddLinkOut(nextItem, link.Type, false);
// add current element to analyze list, to analyze dependencies recursively
if (isRecursive)
{
itemsToAnalyze.Enqueue(nextItem);
}
}
else
{
result.AddBrokenLinkOut(link);
}
}
if (!isRecursive)
{
break;
}
}
}
