private void ClearProperties()
{
// Explicitly clear all properties
ClearProperty(Configuration.JaegerAgentHost);
ClearProperty(Configuration.JaegerAgentPort);
ClearProperty(Configuration.JaegerGrpcTarget);
ClearProperty(Configuration.JaegerGrpcRootCertificate);
ClearProperty(Configuration.JaegerGrpcClientChain);
ClearProperty(Configuration.JaegerGrpcClientKey);
ClearProperty(Configuration.JaegerReporterLogSpans);
ClearProperty(Configuration.JaegerReporterMaxQueueSize);
ClearProperty(Configuration.JaegerReporterFlushInterval);
ClearProperty(Configuration.JaegerSamplerType);
ClearProperty(Configuration.JaegerSamplerParam);
#pragma warning disable CS0618 // Supress warning on obsolete constant: JaegerSamplerManagerHostPort
ClearProperty(Configuration.JaegerSamplerManagerHostPort);
#pragma warning restore CS0618 // Supress warning on obsolete constant: JaegerSamplerManagerHostPort
ClearProperty(Configuration.JaegerSamplingEndpoint);
ClearProperty(Configuration.JaegerServiceName);
ClearProperty(Configuration.JaegerTags);
ClearProperty(Configuration.JaegerSenderFactory);
ClearProperty(Configuration.JaegerTraceId128Bit);
ClearProperty(Configuration.JaegerEndpoint);
ClearProperty(Configuration.JaegerAuthToken);
ClearProperty(Configuration.JaegerUser);
ClearProperty(Configuration.JaegerPassword);
ClearProperty(Configuration.JaegerPropagation);
ClearProperty(TEST_PROPERTY);
// Reset opentracing's global tracer
FieldInfo field = typeof(GlobalTracer).GetField("_tracer", BindingFlags.Instance | BindingFlags.NonPublic);
field.SetValue(GlobalTracer.Instance, NoopTracerFactory.Create());
}
public void Factory_returns_the_same_instance()
{
var tracer1 = NoopTracerFactory.Create();
var tracer2 = NoopTracerFactory.Create();
Assert.Same(tracer1, tracer2);
}
public void When_EnhanchedDurability_Is_False_Hello_Doesnt_Requests_MutationSeqNo()
{
const ulong connectionId = 12345;
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(x => x.ConnectionId).Returns(connectionId);
var mockConnectionPool = new Mock <IConnectionPool>();
mockConnectionPool.Setup(x => x.Acquire()).Returns(mockConnection.Object);
mockConnectionPool.SetupGet(x => x.Configuration).Returns(new PoolConfiguration
{
UseEnhancedDurability = false,
ClientConfiguration = new ClientConfiguration {
Tracer = NoopTracerFactory.Create()
}
});
var service = new MultiplexingIOService(mockConnectionPool.Object);
service.Execute(new FakeOperationWithRequiredKey("key", null, new DefaultTranscoder(), 0));
var features = new[]
{
(short)ServerFeatures.SubdocXAttributes,
(short)ServerFeatures.SelectBucket,
(short)ServerFeatures.XError,
(short)ServerFeatures.ServerDuration
};
var key = IOServiceBase.BuildHelloKey(connectionId);
var expectedBytes = new Hello(key, features.ToArray(), new DefaultTranscoder(), 0, 0).Write();
mockConnectionPool.Verify(x => x.Acquire(), Times.Once);
mockConnection.Verify(x => x.Send(It.Is <byte[]>(bytes => bytes.SequenceEqual(expectedBytes))));
}
private void ClearProperties()
{
// Explicitly clear all properties
ClearProperty(Configuration.JaegerAgentHost);
ClearProperty(Configuration.JaegerAgentPort);
ClearProperty(Configuration.JaegerReporterLogSpans);
ClearProperty(Configuration.JaegerReporterMaxQueueSize);
ClearProperty(Configuration.JaegerReporterFlushInterval);
ClearProperty(Configuration.JaegerSamplerType);
ClearProperty(Configuration.JaegerSamplerParam);
ClearProperty(Configuration.JaegerSamplerManagerHostPort);
ClearProperty(Configuration.JaegerServiceName);
ClearProperty(Configuration.JaegerTags);
ClearProperty(Configuration.JaegerTraceId128Bit);
ClearProperty(Configuration.JaegerEndpoint);
ClearProperty(Configuration.JaegerAuthToken);
ClearProperty(Configuration.JaegerUser);
ClearProperty(Configuration.JaegerPassword);
ClearProperty(Configuration.JaegerPropagation);
ClearProperty(TestProperty);
// Reset opentracing's global tracer
FieldInfo field = typeof(GlobalTracer).GetField("_tracer", BindingFlags.Instance | BindingFlags.NonPublic);
field.SetValue(GlobalTracer.Instance, NoopTracerFactory.Create());
}
public static IHttpClientBuilder WithTracing(this IHttpClientBuilder clientBuilder)
{
clientBuilder.Services.TryAddSingleton <ITracer>(NoopTracerFactory.Create());
clientBuilder.Services.AddTransient <TracingHttpMessageHandler>();
clientBuilder.AddHttpMessageHandler <TracingHttpMessageHandler>();
return(clientBuilder);
}
public void Start_returns_NoopSpan()
{
var tracer = NoopTracerFactory.Create();
var span = tracer.BuildSpan("noop").Start();
Assert.IsType <NoopSpan>(span);
}
public void Start_does_NOT_set_ScopeManager_Active()
{
var tracer = NoopTracerFactory.Create();
var span = tracer.BuildSpan("noop").Start();
Assert.Null(tracer.ScopeManager.Active);
}
static NoOp()
{
var noOpTracer = NoopTracerFactory.Create();
Span = noOpTracer.BuildSpan("foo").Start();
Scope = noOpTracer.ScopeManager.Active;
ScopeManager = noOpTracer.ScopeManager;
}
public void Span_has_NoopSpanContext()
{
var tracer = NoopTracerFactory.Create();
var span = tracer.BuildSpan("noop").Start();
Assert.IsType <NoopSpanContext>(span.Context);
}
public void BuildSpan_returns_NoopSpanBuilder()
{
var tracer = NoopTracerFactory.Create();
var spanBuilder = tracer.BuildSpan("noop");
Assert.IsType <NoopSpanBuilder>(spanBuilder);
}
public HandleEventTest()
{
_microsoftSqlClientDiagnostics = new MicrosoftSqlClientDiagnostics(
NullLoggerFactory.Instance,
NoopTracerFactory.Create(),
Options.Create(new MicrosoftSqlClientDiagnosticOptions {
StartRootSpans = false
}));
}
public void Start_always_returns_same_Span()
{
var tracer = NoopTracerFactory.Create();
var span1 = tracer.BuildSpan("noop1").Start();
var span2 = tracer.BuildSpan("noop2").Start();
Assert.Same(span1, span2);
}
public void NoopScope_from_StartActive_has_NoopSpan()
{
var tracer = NoopTracerFactory.Create();
var scope = tracer.BuildSpan("noop")
.StartActive(finishSpanOnDispose: false);
Assert.IsType <NoopSpan>(scope.Span);
}
public void BuildSpan_always_returns_same_Builder()
{
var tracer = NoopTracerFactory.Create();
var builder1 = tracer.BuildSpan("noop1");
var builder2 = tracer.BuildSpan("noop2");
Assert.Same(builder1, builder2);
}
public void StartActive_returns_NoopScope()
{
var tracer = NoopTracerFactory.Create();
var scope = tracer.BuildSpan("noop")
.StartActive(finishSpanOnDispose: false);
Assert.IsType <NoopScopeManager.NoopScope>(scope);
}
public void StartActive_does_NOT_set_ScopeManager_Active()
{
var tracer = NoopTracerFactory.Create();
var scope = tracer.BuildSpan("noop")
.StartActive(finishSpanOnDispose: false);
Assert.Null(tracer.ScopeManager.Active);
}
public void Extract_returns_NoopSpanContext()
{
var tracer = NoopTracerFactory.Create();
var carrier = new Dictionary <string, string>();
var spanContext = tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(carrier));
Assert.IsType <NoopSpanContext>(spanContext);
}
public void ScopeManager_does_NOT_set_Active_on_Activate()
{
var tracer = NoopTracerFactory.Create();
var span = tracer.BuildSpan("noop").Start();
tracer.ScopeManager.Activate(span, finishSpanOnDispose: false);
Assert.Null(tracer.ScopeManager.Active);
Assert.Null(tracer.ActiveSpan);
}
public void Init()
{
//If no global tracer is registered (not running with scope-run), we register the Noop tracer
if (!GlobalTracer.IsRegistered())
{
GlobalTracer.Register(NoopTracerFactory.Create());
}
var loggerFactory = new LoggerFactory();
_logger = loggerFactory.CreateLogger <GeoIntegrationTest>();
}
private static void RegisterSharedDefaults(IContainer container)
{
#region Singletons
container.Register <IContainerFactory, ContainerFactory>(LifeStyles.Singleton);
//register the generic configuration container
container.Register <IConfiguration, AdditionalConfiguration>(LifeStyles.Singleton);
#endregion
#region Logging
#if (DEBUG)
container.Register <ILogger>(() => new ConsoleLogger(LoggingEventType.Debug), LifeStyles.Singleton);
#else
container.Register <ILogger>(() => new NullLogger(), LifeStyles.Singleton);
#endif
#endregion
#region Open Tracing
var tracer = NoopTracerFactory.Create();
container.Register <ITracer>(() => tracer, LifeStyles.Singleton);
#endregion
container.Register <BaseTimeConfiguration>(LifeStyles.Singleton);
container.Register <IGetTimeFactory, GetTimeFactory>(LifeStyles.Singleton);
container.Register <IGetTime, LocalMachineTime>(LifeStyles.Singleton);
container.Register <IInterceptorFactory, InterceptorFactory>(LifeStyles.Singleton);
container.RegisterCollection <IMessageInterceptor>(Enumerable.Empty <Type>());
container.Register <IPolicies, Policies.Policies>(LifeStyles.Singleton);
container.Register <PolicyRegistry>(LifeStyles.Singleton);
container.Register <PolicyDefinitions>(LifeStyles.Singleton);
//because of it's usage in 'standard' modules, this must always be added.
//otherwise, the IoC container can't create the producer queue.
container.Register <IMessageContextDataFactory, MessageContextDataFactory>(LifeStyles.Singleton);
container.Register <IHeaders, Headers>(LifeStyles.Singleton);
container.Register <IStandardHeaders, StandardHeaders>(LifeStyles.Singleton);
container.Register <ICustomHeaders, CustomHeaders>(LifeStyles.Singleton);
RegisterMetricDecorators(container);
RegisterPolicyDecorators(container);
RegisterLoggerDecorators(container);
RegisterTraceDecorators(container);
//register the linq cache decorator
container.RegisterDecorator <ILinqCompiler, LinqCompileCacheDecorator>(LifeStyles.Singleton);
}
public void Inject_does_not_modify_carrier()
{
var tracer = NoopTracerFactory.Create();
var span = tracer.BuildSpan("noop").Start();
span.SetBaggageItem("key", "value");
var carrier = new Dictionary <string, string>();
tracer.Inject(span.Context, BuiltinFormats.TextMap, new TextMapInjectAdapter(carrier));
Assert.Empty(carrier);
}
public void Result_Has_KVError_In_Message_If_ErrorMap_Available_And_Failure()
{
const string codeString = "2c"; // 44
var code = short.Parse(codeString, NumberStyles.HexNumber);
var errorCode = new ErrorCode {
Name = "test"
};
var errorMap = new ErrorMap
{
Version = 1,
Revision = 1,
Errors = new Dictionary <string, ErrorCode>
{
{ codeString, errorCode }
}
};
var converter = new DefaultConverter();
var responseBytes = new byte[24];
converter.FromByte((byte)Magic.Response, responseBytes, HeaderIndexFor.Magic);
converter.FromInt16(code, responseBytes, HeaderIndexFor.Status);
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(x => x.IsConnected).Returns(true);
mockConnection.Setup(x => x.Send(It.IsAny <byte[]>())).Returns(responseBytes);
var mockConnectionPool = new Mock <IConnectionPool>();
mockConnectionPool.Setup(x => x.Acquire()).Returns(mockConnection.Object);
mockConnectionPool.SetupGet(x => x.Configuration).Returns(new PoolConfiguration
{
ClientConfiguration = new ClientConfiguration {
Tracer = NoopTracerFactory.Create()
}
});
mockConnectionPool.Setup(x => x.Connections).Returns(new List <IConnection> {
mockConnection.Object
});
var service = new PooledIOService(mockConnectionPool.Object)
{
ErrorMap = errorMap
};
var result = service.Execute(new FakeOperationWithRequiredKey("key", null, new DefaultTranscoder(), 0, 0));
Assert.True(result.Message.Contains("KV Error"));
}
public static bool IsNoopTracer(this ITracer tracer)
{
// TODO Change if https://github.com/opentracing/opentracing-csharp/pull/77 gets released.
if (tracer == NoopTracerFactory.Create())
{
return(true);
}
// There's no way to check the underlying tracer on the instance so we have to check the static method.
if (tracer is GlobalTracer && !GlobalTracer.IsRegistered())
{
return(true);
}
return(false);
}
public void Does_not_Start_if_Tracer_is_NoopTracer()
{
var loggerFactory = new NullLoggerFactory();
var tracer = NoopTracerFactory.Create();
var diagnosticSubscribers = new List <DiagnosticObserver>();
var options = Options.Create(new DiagnosticManagerOptions());
using (DiagnosticManager diagnosticManager = new DiagnosticManager(loggerFactory, tracer, diagnosticSubscribers, options))
{
Assert.False(diagnosticManager.IsRunning);
diagnosticManager.Start();
Assert.False(diagnosticManager.IsRunning);
}
}
public static IOpenTracingBuilder AddBenchmarkTracer(this IOpenTracingBuilder builder, InstrumentationMode mode)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
ITracer tracer = mode == InstrumentationMode.Mock
? new MockTracer()
: NoopTracerFactory.Create();
bool startInstrumentationForNoopTracer = mode == InstrumentationMode.Noop;
builder.Services.AddSingleton <ITracer>(tracer);
builder.Services.Configure <DiagnosticManagerOptions>(options => options.StartInstrumentationForNoopTracer = startInstrumentationForNoopTracer);
return(builder);
}
public void When_NotConnected_Execute_ReturnsTransportFailureException()
{
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(x => x.IsConnected).Returns(false);
var mockConnectionPool = new Mock <IConnectionPool>();
mockConnectionPool.Setup(x => x.Acquire()).Returns(mockConnection.Object);
mockConnectionPool.SetupGet(x => x.Configuration).Returns(new PoolConfiguration
{
UseEnhancedDurability = false,
ClientConfiguration = new ClientConfiguration {
Tracer = NoopTracerFactory.Create()
}
});
var service = new MultiplexingIOService(mockConnectionPool.Object);
var result = service.Execute(new FakeOperationWithRequiredKey("key", null, new DefaultTranscoder(), 0));
Assert.AreEqual(result.Status, ResponseStatus.TransportFailure);
Assert.IsFalse(result.Success);
Assert.IsInstanceOf <TransportFailureException>(result.Exception);
}
internal static ITracer CreateLogger()
{
var assembly = Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly();
var config = ConfigurationManager.OpenExeConfiguration(assembly.Location);
var cfg = config.GetSection(SectionName) as JaegerConfigurationSection;
if (cfg == null || !cfg.Enabled)
{
return(NoopTracerFactory.Create());
}
var sender = default(ThriftSender);
if (cfg.UseUdp)
{
var udp = cfg.UdpSender;
sender = new UdpSender(udp.Host, udp.Port, udp.MaxPacketSize);
}
else
{
var http = cfg.HttpSender;
sender = new HttpSender.Builder($"http://{http.Host}:{http.Port}/api/traces")
.WithMaxPacketSize(http.MaxPacketSize)
.Build();
}
var sampler = new ConstSampler(true);
var reporter = new RemoteReporter.Builder()
.WithSender(sender)
.Build();
return(new Tracer.Builder(cfg.ServiceName)
.WithReporter(reporter)
.WithSampler(sampler)
.Build());
}
public void Tracer_uses_NoopScopeManager()
{
var tracer = NoopTracerFactory.Create();
Assert.IsType <NoopScopeManager>(tracer.ScopeManager);
}
public static ITracer Init(string service)
{
// TODO: Replace this with Wavefront Tracer
return(NoopTracerFactory.Create());
}
public void Tracer_initially_has_no_active_span()
{
var tracer = NoopTracerFactory.Create();
Assert.Null(tracer.ActiveSpan);
}
