public void SubscribeDuplicateDiagnosticListenerTypesShouldOnlySubscribeSingle()
{
using (var listener = new DiagnosticListener("Test"))
{
var logger = new InMemoryBlockingLogger(LogLevel.Debug);
using var agent = new ApmAgent(new TestAgentComponents(logger: logger));
agent.Subscribe(new TestSubscriber());
agent.Subscribe(new TestSubscriber());
logger.Lines.Should().Contain(line => line.Contains($"Subscribed {typeof(TestListener).FullName} to `Test' events source"));
logger.Lines.Should().Contain(line => line.Contains($"already subscribed to `Test' events source"));
agent.SubscribedListeners.Should().HaveCount(1).And.Contain(typeof(TestListener));
}
}
public async Task ExceptionDoesNotCauseLoseOfSpan()
{
var payloadSender = new MockPayloadSender();
var cluster = VirtualClusterWith.Nodes(2)
.ClientCalls(r => r.OnPort(9200).FailAlways())
.ClientCalls(c => c.OnPort(9201).FailAlways(new Exception("boom!")))
.StaticConnectionPool()
.AllDefaults();
var client = cluster.Client;
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
using (agent.Subscribe(new ElasticsearchDiagnosticsSubscriber()))
{
try
{
var searchResponse = await agent.Tracer.CaptureTransaction("Call Client", ApiConstants.ActionExec,
async() => await client.SearchAsync <StringResponse>(PostData.Empty)
);
searchResponse.Should().NotBeNull();
}
catch (Exception) { }
var spans = payloadSender.SpansOnFirstTransaction;
spans.Should().NotBeEmpty();
spans.Should().Contain(s => s.Context.Db.Statement != null);
//ensure we the last span is closed even if the listener does not receive a response
spans.Where(s => s.Action == "Ping").Should().HaveCount(2);
spans.Where(s => s.Action == "CallElasticsearch").Should().HaveCount(2);
payloadSender.Errors.Should().Contain(e => ((Error)e).Exception.Message == "boom!");
}
}
public async Task HttpCallWithW3CActivityFormar()
{
Activity.DefaultIdFormat = ActivityIdFormat.W3C;
var mockPayloadSender = new MockPayloadSender();
using var localServer = LocalServer.Create();
using var agent = new ApmAgent(new TestAgentComponents(payloadSender: mockPayloadSender));
agent.Subscribe(new HttpDiagnosticsSubscriber());
await agent.Tracer.CaptureTransaction("Test", "Test", async() =>
{
var httpClient = new HttpClient();
try
{
await httpClient.GetAsync(localServer.Uri);
}
catch
{
//ignore - we don't care about the result
}
});
mockPayloadSender.WaitForSpans();
mockPayloadSender.Spans.Should().HaveCount(1);
}
internal static HttpClient GetClientWithoutExceptionPage <T>(ApmAgent agent, WebApplicationFactory <T> factory, bool useOnlyDiagnosticSource) where T : class
{
var builder = factory
.WithWebHostBuilder(n =>
{
n.Configure(app =>
{
if (useOnlyDiagnosticSource)
{
var subs = new IDiagnosticsSubscriber[]
{
new HttpDiagnosticsSubscriber(),
new EfCoreDiagnosticsSubscriber(),
new AspNetCoreDiagnosticSubscriber()
};
agent.Subscribe(subs);
}
else
{
app.UseElasticApm(agent, agent.Logger, new HttpDiagnosticsSubscriber(), new EfCoreDiagnosticsSubscriber());
}
Startup.ConfigureRoutingAndMvc(app);
});
n.ConfigureServices(ConfigureServices);
});
return(builder.CreateClient());
}
public async Task NoUserNameAndPasswordInLogsForHttp()
{
var payloadSender = new NoopPayloadSender();
var logger = new TestLogger(LogLevel.Trace);
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender, logger: logger));
agent.Subscribe(new HttpDiagnosticsSubscriber());
StartTransaction(agent);
using (var localServer = LocalServer.Create())
using (var httpClient = new HttpClient())
{
var uriBuilder = new UriBuilder(localServer.Uri)
{
UserName = "******", Password = "******"
};
var res = await httpClient.GetAsync(uriBuilder.Uri);
res.IsSuccessStatusCode.Should().BeTrue();
logger.Lines.Should().NotBeEmpty();
logger.Lines.Should().NotContain(n => n.Contains("TestUser289421"));
logger.Lines.Should().NotContain(n => n.Contains("Password973243"));
// looking for lines with "localhost:8082" and asserting that those contain [REDACTED].
foreach (var lineWithHttpLog in logger.Lines.Where(n => n.Contains($"{uriBuilder.Host}:{uriBuilder.Port}")))
{
lineWithHttpLog.Should().Contain("[REDACTED]");
}
}
}
public void Call_to_Elasticsearch_propagates_Trace_Context_when_HttpDiagnosticsSubscriber_subscribed()
{
using var localServer = LocalServer.Create(context =>
{
var traceparent = context.Request.Headers.Get("traceparent");
traceparent.Should().NotBeNullOrEmpty();
var elasticTraceparent = context.Request.Headers.Get("elastic-apm-traceparent");
elasticTraceparent.Should().NotBeNullOrEmpty().And.Be(traceparent);
var tracestate = context.Request.Headers.Get("tracestate");
tracestate.Should().NotBeNullOrEmpty().And.Contain("es=s:1");
context.Response.StatusCode = 200;
});
using var agent = new ApmAgent(new TestAgentComponents(payloadSender: new MockPayloadSender(), configuration: new MockConfiguration(exitSpanMinDuration: "0", spanCompressionEnabled: "false")));
using var subscribe = agent.Subscribe(new ElasticsearchDiagnosticsSubscriber(), new HttpDiagnosticsSubscriber());
var client = new ElasticLowLevelClient(new ConnectionConfiguration(new Uri(localServer.Uri)));
agent.Tracer.CaptureTransaction("Transaction", ApiConstants.TypeDb, t =>
{
var response = client.Cat.Indices <StringResponse>();
});
}
[NetCoreFact] //see: https://github.com/elastic/apm-agent-dotnet/issues/516
public async Task HttpCallWithRegisteredListener()
{
var mockPayloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: mockPayloadSender));
var subscriber = new HttpDiagnosticsSubscriber();
using (var localServer = LocalServer.Create())
using (agent.Subscribe(subscriber))
{
var url = localServer.Uri;
await agent.Tracer.CaptureTransaction("TestTransaction", "TestType", async t =>
{
Thread.Sleep(5);
var httpClient = new HttpClient();
try
{
await httpClient.GetAsync(url);
}
catch (Exception e)
{
t.CaptureException(e);
}
});
mockPayloadSender.WaitForTransactions();
mockPayloadSender.Transactions.Should().NotBeEmpty();
mockPayloadSender.WaitForSpans();
mockPayloadSender.SpansOnFirstTransaction.Should().NotBeEmpty();
mockPayloadSender.SpansOnFirstTransaction[0].Context.Http.Should().NotBeNull();
mockPayloadSender.SpansOnFirstTransaction[0].Context.Http.Url.Should().Be(url);
}
}
internal static IApplicationBuilder UseElasticApm(
this IApplicationBuilder builder,
ApmAgent agent,
IApmLogger logger,
params IDiagnosticsSubscriber[] subscribers
)
{
if (!agent.ConfigurationReader.Enabled)
{
if (!Agent.IsConfigured)
{
Agent.Setup(agent);
}
logger?.Info()?.Log("The 'Enabled' agent config is set to false - the agent won't collect and send any data.");
return(builder);
}
var subs = new List <IDiagnosticsSubscriber>(subscribers ?? Array.Empty <IDiagnosticsSubscriber>())
{
new AspNetCoreErrorDiagnosticsSubscriber()
};
agent.Subscribe(subs.ToArray());
return(builder.UseMiddleware <ApmMiddleware>(agent.Tracer, agent));
}
internal static HttpClient GetClientWithoutExceptionPage <T>(ApmAgent agent, WebApplicationFactory <T> factory, bool useOnlyDiagnosticSource) where T : class
{
var builder = factory
.WithWebHostBuilder(n =>
{
n.Configure(app =>
{
if (useOnlyDiagnosticSource)
{
var subs = new List <IDiagnosticsSubscriber>()
{
new AspNetCoreErrorDiagnosticsSubscriber(),
new AspNetCoreDiagnosticSubscriber()
};
agent.Subscribe(subs.ToArray());
}
else
{
app.UseElasticApm(agent, agent.Logger, new HttpDiagnosticsSubscriber(), new EfCoreDiagnosticsSubscriber());
}
RegisterRoutingAndMvc(app);
});
n.ConfigureServices(ConfigureServices);
});
#if !NETCOREAPP2_1 && !NETCOREAPP2_2
builder.Server.AllowSynchronousIO = true;
#endif
return(builder.CreateClient());
}
/// <summary>
/// Register Elastic APM .NET Agent with components in the container.
/// You can customize the agent by passing additional IDiagnosticsSubscriber components to this method.
/// Use this method if you want to control what tracing capability of the agent you would like to use
/// or in case you want to minimize the number of dependencies added to your application.
/// If you want to simply enable every tracing component without configuration please use the
/// UseAllElasticApm extension method from the Elastic.Apm.NetCoreAll package.
/// </summary>
/// <param name="builder">Builder.</param>
/// <param name="subscribers">Specify which diagnostic source subscribers you want to connect.</param>
public static IHostBuilder UseElasticApm(this IHostBuilder builder, params IDiagnosticsSubscriber[] subscribers)
{
builder.ConfigureServices((ctx, services) =>
{
services.AddSingleton <IApmLogger, NetCoreLogger>();
services.AddSingleton <IConfigurationReader>(sp =>
new MicrosoftExtensionsConfig(ctx.Configuration, sp.GetService <IApmLogger>(), ctx.HostingEnvironment.EnvironmentName));
services.AddSingleton(sp =>
{
var components = new AgentComponents(sp.GetService <IApmLogger>(), sp.GetService <IConfigurationReader>());
UpdateServiceInformation(components.Service);
return(components);
});
services.AddSingleton <IApmAgent, ApmAgent>(sp =>
{
var apmAgent = new ApmAgent(sp.GetService <AgentComponents>());
if (subscribers != null && subscribers.Any())
{
apmAgent.Subscribe(subscribers);
}
return(apmAgent);
});
services.AddSingleton(sp => sp.GetRequiredService <IApmAgent>().Tracer);
});
return(builder);
}
[NetCoreFact] //see: https://github.com/elastic/apm-agent-dotnet/issues/516
public async Task SubscriptionOnlyRegistersSpansDuringItsLifeTime()
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
StartTransaction(agent);
var spans = payloadSender.Spans;
using (var localServer = new LocalServer())
using (var httpClient = new HttpClient())
{
spans.Should().BeEmpty();
using (agent.Subscribe(new HttpDiagnosticsSubscriber()))
{
var res = await httpClient.GetAsync(localServer.Uri);
res.IsSuccessStatusCode.Should().BeTrue();
res = await httpClient.GetAsync(localServer.Uri);
res.IsSuccessStatusCode.Should().BeTrue();
}
spans = payloadSender.Spans;
spans.Should().NotBeEmpty().And.HaveCount(2);
foreach (var _ in Enumerable.Range(0, 10))
{
await httpClient.GetAsync(localServer.Uri);
}
localServer.SeenRequests.Should()
.BeGreaterOrEqualTo(10,
"Make sure we actually performed more than 1 request to our local server");
}
spans.Should().HaveCount(2);
}
public async Task HttpCallWithRegisteredListener()
{
var mockPayloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: mockPayloadSender));
var subscriber = new HttpDiagnosticsSubscriber();
using (var localServer = new LocalServer())
using (agent.Subscribe(subscriber))
{
var url = localServer.Uri;
await agent.Tracer.CaptureTransaction("TestTransaction", "TestType", async t =>
{
Thread.Sleep(5);
var httpClient = new HttpClient();
try
{
await httpClient.GetAsync(url);
}
catch (Exception e)
{
t.CaptureException(e);
}
});
Assert.NotEmpty(mockPayloadSender.Payloads[0].Transactions);
Assert.NotEmpty(mockPayloadSender.SpansOnFirstTransaction);
Assert.NotNull(mockPayloadSender.SpansOnFirstTransaction[0].Context.Http);
Assert.Equal(url, mockPayloadSender.SpansOnFirstTransaction[0].Context.Http.Url);
}
}
public async Task ElasticsearchClientExceptionIsReported()
{
var payloadSender = new MockPayloadSender();
var cluster = VirtualClusterWith.Nodes(1)
.ClientCalls(r => r.OnPort(9200).FailAlways())
.StaticConnectionPool()
.Settings(s => s.DisablePing());
var client = cluster.Client;
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
using (agent.Subscribe(new ElasticsearchDiagnosticsSubscriber()))
{
var searchResponse = await agent.Tracer.CaptureTransaction("Call Client", ApiConstants.ActionExec,
async() => await client.SearchAsync <StringResponse>(PostData.Empty)
);
searchResponse.Should().NotBeNull();
var spans = payloadSender.SpansOnFirstTransaction;
var span = spans.Should().NotBeEmpty().And.HaveCount(1).And.Subject.First();
span.Outcome.Should().Be(Outcome.Failure);
var error = (Error)payloadSender.Errors.Should().HaveCount(1).And.Subject.First();
error.Culprit.Should().StartWith("Elasticsearch.Net.VirtualizedCluster.VirtualClusterConnection");
error.Exception.Should().NotBeNull();
error.Exception.Message.Should().Contain("System.Net.Http.HttpRequestException");
error.Exception.StackTrace.Should().NotBeEmpty();
error.Exception.StackTrace.Should().OnlyContain(s => s.LineNo > 0);
}
}
public async Task SubscriptionOnlyRegistersSpansDuringItsLifeTime()
{
var agent = new ApmAgent(new TestAgentComponents());
StartTransaction(agent);
var spans = Agent.TransactionContainer.Transactions.Value.Spans;
using (var localServer = new LocalServer())
using (var httpClient = new HttpClient())
{
Assert.True(spans.Length == 0, $"Expected 0 spans has count: {spans.Length}");
using (agent.Subscribe(new HttpDiagnosticsSubscriber()))
{
var res = await httpClient.GetAsync(localServer.Uri);
Assert.True(res.IsSuccessStatusCode);
res = await httpClient.GetAsync(localServer.Uri);
Assert.True(res.IsSuccessStatusCode);
}
spans = Agent.TransactionContainer.Transactions.Value.Spans;
Assert.True(spans.Length == 2, $"Expected 2 but spans has count: {spans.Length}");
foreach (var _ in Enumerable.Range(0, 10))
{
await httpClient.GetAsync(localServer.Uri);
}
Assert.True(localServer.SeenRequests > 10, "Make sure we actually performed more than 1 request to our local server");
}
Assert.True(spans.Length == 2, $"Expected 1 span because the listener is disposed but spans has count: {spans.Length}");
}
internal static IApplicationBuilder UseElasticApm(
this IApplicationBuilder builder,
ApmAgent agent,
IApmLogger logger,
params IDiagnosticsSubscriber[] subscribers
)
{
if (!agent.ConfigurationReader.Enabled)
{
if (!Agent.IsConfigured)
{
Agent.Setup(agent);
}
logger?.Info()?.Log("The 'Enabled' agent config is set to false - the agent won't collect and send any data.");
return(builder);
}
var subs = subscribers?.ToList() ?? new List <IDiagnosticsSubscriber>(1);
if (subs.Count == 0 || subs.All(s => s.GetType() != typeof(AspNetCoreErrorDiagnosticsSubscriber)))
{
subs.Add(new AspNetCoreErrorDiagnosticsSubscriber());
}
agent.Subscribe(subs.ToArray());
return(builder.UseMiddleware <ApmMiddleware>(agent.Tracer, agent));
}
public async Task FailOverResultsInSpans()
{
var payloadSender = new MockPayloadSender();
var cluster = VirtualClusterWith.Nodes(10)
.ClientCalls(c => c.FailAlways())
.ClientCalls(r => r.OnPort(9209).SucceedAlways())
.StaticConnectionPool()
.AllDefaults();
var client = cluster.Client;
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
using (agent.Subscribe(new ElasticsearchDiagnosticsSubscriber()))
{
var searchResponse = await agent.Tracer.CaptureTransaction("Call Client", ApiConstants.ActionExec,
async() => await client.SearchAsync <StringResponse>(PostData.Empty)
);
searchResponse.Should().NotBeNull();
searchResponse.Success.Should().BeTrue();
searchResponse.AuditTrail.Should().NotBeEmpty();
var failed = searchResponse.AuditTrail.Where(a => a.Event == AuditEvent.BadResponse);
failed.Should().HaveCount(9);
var spans = payloadSender.SpansOnFirstTransaction;
spans.Should().NotBeEmpty();
var pings = spans.Where(s => s.Action == "Ping");
pings.Should().HaveCount(10);
spans.Where(s => s.Action == "CallElasticsearch").Should().HaveCount(10);
spans.Should().OnlyContain(s => s.Context != null);
spans.Should().OnlyContain(s => s.Context.Db != null);
spans.Should().OnlyContain(s => s.Context.Db.Statement != null);
}
}
public void Context_Destination_from_Db(ExternalDbType externalDbType, ConnectionDetails connectionDetails)
{
if (connectionDetails == null)
{
return;
}
var mockPayloadSender = new MockPayloadSender();
using (var agent = new ApmAgent(new AgentComponents(payloadSender: mockPayloadSender)))
{
agent.Subscribe(new EfCoreDiagnosticsSubscriber());
agent.Tracer.CaptureTransaction("test TX name", "test TX type"
, () => { ExecuteTestCrudSequence(() => externalDbType.DbContextBuilder(connectionDetails)); });
}
mockPayloadSender.Transactions.Should().HaveCount(1);
mockPayloadSender.Spans.ForEach(span =>
{
span.Type.Should().Be(ApiConstants.TypeDb);
span.Subtype.Should().Be(externalDbType.SpanSubtype);
span.Action.Should().Be(ApiConstants.ActionQuery);
span.Context.Db.Type.Should().Be(Database.TypeSql);
span.Context.Destination.Address.Should().Be(connectionDetails.Host);
span.Context.Destination.Port.Should().Be(externalDbType.DefaultPort);
});
}
public async Task FailingGrpcCallTest(bool withDiagnosticSource)
{
var payloadSender = new MockPayloadSender();
using var apmAgent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
var sampleAppHost = withDiagnosticSource
? new SampleAppHostBuilder().BuildHost()
: new SampleAppHostBuilder().BuildHostWithMiddleware(apmAgent);
apmAgent.Subscribe(new AspNetCoreDiagnosticSubscriber(), new GrpcClientDiagnosticSubscriber(), new HttpDiagnosticsSubscriber());
await sampleAppHost.StartAsync();
AppContext.SetSwitch(
"System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var channel = GrpcChannel.ForAddress(SampleAppHostBuilder.SampleAppUrl);
var client = new Greeter.GreeterClient(channel);
await apmAgent.Tracer.CaptureTransaction("SampleCall", "test", async() =>
{
try
{
var response = await client.ThrowAnExceptionAsync(
new HelloRequest {
Name = "World"
});
Debug.WriteLine(response.Message);
}
catch
{
//Ignore exception
}
});
payloadSender.Transactions.Should()
.Contain(transaction => transaction.Result == "UNKNOWN" &&
transaction.Name == $"/{Greeter.Descriptor.FullName}/{nameof(client.ThrowAnException)}" &&
transaction.Outcome == Outcome.Failure);
//Make sure all spans are collected
Thread.Sleep(500);
payloadSender.Spans.Should().HaveCountGreaterThan(1);
payloadSender.Spans.Should()
.Contain(span => span.Subtype == ApiConstants.SubTypeGrpc &&
span.Outcome == Outcome.Failure &&
span.Name == $"/{Greeter.Descriptor.FullName}/{nameof(client.ThrowAnException)}" &&
span.Context.Destination.Address == "localhost" &&
span.Context.Destination.Port == SampleAppHostBuilder.SampleAppPort &&
span.Context.Destination.Service.Type == "external" &&
span.Context.Destination.Service.Name == SampleAppHostBuilder.SampleAppUrl &&
span.Context.Destination.Service.Resource == $"localhost:{SampleAppHostBuilder.SampleAppPort}"
);
await sampleAppHost.StopAsync();
}
public MicrosoftAzureDocumentDbTests(AzureCosmosDbTestEnvironment environment, ITestOutputHelper output)
{
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureCosmosDbDiagnosticsSubscriber());
_client = new DocumentClient(new Uri(environment.Endpoint), environment.PrimaryMasterKey);
}
public async Task ServerErrorIsReported()
{
var payloadSender = new MockPayloadSender();
var cluster = VirtualClusterWith.Nodes(1)
.ClientCalls(r => r
.FailAlways(500)
.ReturnResponse(new
{
error = new
{
root_cause =
new object[]
{
new
{
type = "script_exception",
reason = "runtime error",
script_stack = new string[] { },
script = "ctx._source",
lang = "painless"
}
},
type = "script_exception",
reason = "runtime error",
script_stack = new string[] {},
script = "ctx._source",
lang = "painless",
caused_by = new {
type = "null_pointer_exception",
reason = (object)null
}
},
status = 500
})
)
.StaticConnectionPool()
.Settings(s => s.DisablePing());
var client = cluster.Client;
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
using (agent.Subscribe(new ElasticsearchDiagnosticsSubscriber()))
{
var searchResponse = await agent.Tracer.CaptureTransaction("Call Client", ApiConstants.ActionExec,
async() => await client.SearchAsync <StringResponse>(PostData.Empty)
);
searchResponse.Should().NotBeNull();
var spans = payloadSender.SpansOnFirstTransaction;
var span = spans.Should().NotBeEmpty().And.HaveCount(1).And.Subject.First();
var error = (Elastic.Apm.Model.Error)payloadSender.Errors.Should().HaveCount(1).And.Subject.First();
error.Culprit.Should().StartWith("Elasticsearch Server Error: script_exception");
error.Exception.Should().NotBeNull();
error.Exception.Message.Should().Contain("null_pointer_exception");
error.Exception.Message.Should().Contain("(500)");
}
}
protected BlobStorageTestsBase(AzureStorageTestEnvironment environment, ITestOutputHelper output)
{
Environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
Agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
Agent.Subscribe(new AzureBlobStorageDiagnosticsSubscriber());
}
public EfCoreWithMsSqlTests(ITestOutputHelper testOutputHelper, DatabaseFixture sqlClientListenerFixture)
{
_connectionString = sqlClientListenerFixture.ConnectionString;
_payloadSender = new MockPayloadSender();
_apmAgent = new ApmAgent(new AgentComponents(
new LineWriterToLoggerAdaptor(new XunitOutputToLineWriterAdaptor(testOutputHelper)),
payloadSender: _payloadSender));
_apmAgent.Subscribe(new SqlClientDiagnosticSubscriber(), new EfCoreDiagnosticsSubscriber());
}
public AzureQueueStorageDiagnosticListenerTests(AzureStorageTestEnvironment environment, ITestOutputHelper output)
{
_environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureQueueStorageDiagnosticsSubscriber());
}
internal static (IDisposable, MockPayloadSender, ApmAgent) RegisterListenerAndStartTransaction()
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
var sub = agent.Subscribe(new HttpDiagnosticsSubscriber());
StartTransaction(agent);
return(sub, payloadSender, agent);
}
public MicrosoftAzureServiceBusDiagnosticListenerTests(AzureServiceBusTestEnvironment environment, ITestOutputHelper output)
{
_environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new MicrosoftAzureServiceBusDiagnosticsSubscriber());
_adminClient = new ServiceBusAdministrationClient(environment.ServiceBusConnectionString);
}
public MicrosoftAzureCosmosTests(AzureCosmosDbTestEnvironment environment, ITestOutputHelper output)
{
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureCosmosDbDiagnosticsSubscriber());
_client = new CosmosClient(environment.Endpoint, environment.PrimaryMasterKey, new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Gateway
});
}
internal static IApplicationBuilder UseElasticApm(
this IApplicationBuilder builder,
ApmAgent agent,
params IDiagnosticsSubscriber[] subscribers
)
{
var subs = new List <IDiagnosticsSubscriber>(subscribers ?? Array.Empty <IDiagnosticsSubscriber>());
subs.Add(new AspNetCoreDiagnosticsSubscriber());
agent.Subscribe(subs.ToArray());
return(builder.UseMiddleware <ApmMiddleware>(agent.Tracer));
}
public SqlClientDiagnosticListenerTests()
{
// BUILD_ID env variable is passed from the CI, therefore DockerInDocker is enabled.
_environment = new DockerEnvironmentBuilder()
.DockerInDocker(Environment.GetEnvironmentVariable("BUILD_ID") != null)
.AddMssqlContainer(ContainerName, "StrongPassword!!!!1")
.Build();
_payloadSender = new MockPayloadSender();
_apmAgent = new ApmAgent(new AgentComponents(payloadSender: _payloadSender));
_apmAgent.Subscribe(new SqlClientDiagnosticSubscriber());
}
public void Subscribers_Not_Subscribed_When_Agent_Disabled()
{
var payloadSender = new NoopPayloadSender();
var configReader = new MockConfiguration(enabled: "false");
using var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender, configuration: configReader));
var subscriber = new Mock <IDiagnosticsSubscriber>();
agent.Subscribe(subscriber.Object);
subscriber.Verify(s => s.Subscribe(It.IsAny <IApmAgent>()), Times.Never);
}
public MongoApmTests(MongoFixture <MongoConfiguration, BsonDocument> fixture)
{
_documents = fixture.Collection ?? throw new ArgumentNullException(nameof(fixture.Collection));
_payloadSender = new MockPayloadSender();
var config = new TestAgentComponents(configuration:
new MockConfiguration(transactionSampleRate: "1.0", transactionMaxSpans: "50"),
payloadSender: _payloadSender);
_agent = new ApmAgent(config);
_agent.Subscribe(new MongoDbDiagnosticsSubscriber());
}