Open configuration API (#128)

* Added read-only properties for configurations
* Unified configurations to have GetX methods
* Made GetX methods virtual for overriding
* Add Tracer.Builder read-only properties
* Added obsolete message

Author: Falco20019

src/Jaeger/Configuration.cs

@@ -129,13 +129,12 @@ public enum Propagation
         /// <summary>
         /// The serviceName that the tracer will use.
         /// </summary>
-        private readonly string _serviceName;
+        public string ServiceName { get; }
+
         private readonly ILoggerFactory _loggerFactory;
         private readonly ILogger _logger;
-        private CodecConfiguration _codecConfig;
         private IMetricsFactory _metricsFactory;
         private Dictionary<string, string> _tracerTags;
-        private bool _useTraceId128Bit;
 
         /// <summary>
         /// Lazy singleton <see cref="Tracer"/> initialized in <see cref="GetTracer()"/> method.
@@ -144,10 +143,13 @@ public enum Propagation
 
         public SamplerConfiguration SamplerConfig { get; private set; }
         public ReporterConfiguration ReporterConfig { get; private set; }
+        public CodecConfiguration CodecConfig { get; private set; }
+        public bool UseTraceId128Bit { get; private set; }
+        public IReadOnlyDictionary<string, string> TracerTags => _tracerTags;
 
         public Configuration(string serviceName, ILoggerFactory loggerFactory)
         {
-            _serviceName = Tracer.Builder.CheckValidServiceName(serviceName);
+            ServiceName = Tracer.Builder.CheckValidServiceName(serviceName);
             _loggerFactory = loggerFactory;
             _logger = _loggerFactory.CreateLogger<Configuration>();
         }
@@ -188,30 +190,30 @@ public Tracer.Builder GetTracerBuilder()
             {
                 SamplerConfig = new SamplerConfiguration(_loggerFactory);
             }
-            if (_codecConfig == null)
+            if (CodecConfig == null)
             {
-                _codecConfig = new CodecConfiguration(_loggerFactory);
+                CodecConfig = new CodecConfiguration(_loggerFactory);
             }
             if (_metricsFactory == null)
             {
                 _metricsFactory = NoopMetricsFactory.Instance;
             }
             IMetrics metrics = new MetricsImpl(_metricsFactory);
             IReporter reporter = ReporterConfig.GetReporter(metrics);
-            ISampler sampler = SamplerConfig.CreateSampler(_serviceName, metrics);
-            Tracer.Builder builder = new Tracer.Builder(_serviceName)
+            ISampler sampler = SamplerConfig.GetSampler(ServiceName, metrics);
+            Tracer.Builder builder = new Tracer.Builder(ServiceName)
                 .WithLoggerFactory(_loggerFactory)
                 .WithSampler(sampler)
                 .WithReporter(reporter)
                 .WithMetrics(metrics)
                 .WithTags(_tracerTags);
 
-            if (_useTraceId128Bit)
+            if (UseTraceId128Bit)
             {
                 builder = builder.WithTraceId128Bit();
             }
 
-            _codecConfig.Apply(builder);
+            CodecConfig.Apply(builder);
 
             return builder;
         }
@@ -265,13 +267,13 @@ public Configuration WithSampler(SamplerConfiguration samplerConfig)
 
         public Configuration WithCodec(CodecConfiguration codecConfig)
         {
-            _codecConfig = codecConfig;
+            CodecConfig = codecConfig;
             return this;
         }
 
         public Configuration WithTraceId128Bit(bool useTraceId128Bit)
         {
-            _useTraceId128Bit = useTraceId128Bit;
+            UseTraceId128Bit = useTraceId128Bit;
             return this;
         }
 
@@ -284,6 +286,7 @@ public Configuration WithTracerTags(Dictionary<string, string> tracerTags)
             return this;
         }
 
+        [Obsolete("Use the property 'TracerTags' instead.")]
         public IReadOnlyDictionary<string, string> GetTracerTags()
         {
             return _tracerTags;
@@ -342,8 +345,7 @@ public static SamplerConfiguration FromEnv(ILoggerFactory loggerFactory)
                 return FromIConfiguration(loggerFactory, configuration);
             }
 
-            // for tests
-            internal ISampler CreateSampler(string serviceName, IMetrics metrics)
+            public virtual ISampler GetSampler(string serviceName, IMetrics metrics)
             {
                 string samplerType = StringOrDefault(Type, RemoteControlledSampler.Type);
                 double samplerParam = Param.GetValueOrDefault(ProbabilisticSampler.DefaultSamplingProbability);
@@ -555,7 +557,7 @@ public ReporterConfiguration WithSender(SenderConfiguration senderConfiguration)
                 return this;
             }
 
-            public IReporter GetReporter(IMetrics metrics)
+            public virtual IReporter GetReporter(IMetrics metrics)
             {
                 IReporter reporter = new RemoteReporter.Builder()
                     .WithLoggerFactory(_loggerFactory)
@@ -664,7 +666,7 @@ public SenderConfiguration WithAuthPassword(string password)
             /// configuration's state.
             /// </summary>
             /// <returns>The sender passed via the constructor or a properly configured sender.</returns>
-            public ISender GetSender()
+            public virtual ISender GetSender()
             {
                 // if we have a sender, that's the one we return
                 if (Sender != null)

src/Jaeger/Tracer.cs

@@ -199,26 +199,28 @@ private static string LoadVersion()
 
         public sealed class Builder
         {
-            private ILoggerFactory _loggerFactory;
-            private ISampler _sampler;
-            private IReporter _reporter;
             private PropagationRegistry _registry;
-            private IMetrics _metrics = new MetricsImpl(NoopMetricsFactory.Instance);
-            private readonly string _serviceName;
-            private IClock _clock = new SystemClock();
             private readonly Dictionary<string, object> _tags = new Dictionary<string, object>();
-            private bool _zipkinSharedRpcSpan;
-            private IScopeManager _scopeManager = new AsyncLocalScopeManager();
-            private IBaggageRestrictionManager _baggageRestrictionManager = new DefaultBaggageRestrictionManager();
-            private bool _expandExceptionLogs;
-            private bool _useTraceId128Bit;
 
             // We need the loggerFactory for the PropagationRegistry so we have to defer these invocations.
             private readonly List<Action<PropagationRegistry>> _registryActions = new List<Action<PropagationRegistry>>();
 
+            public string ServiceName { get; }
+            public ILoggerFactory LoggerFactory { get; private set; }
+            public IBaggageRestrictionManager BaggageRestrictionManager { get; private set; } = new DefaultBaggageRestrictionManager();
+            public IMetrics Metrics { get; private set; } = new MetricsImpl(NoopMetricsFactory.Instance);
+            public bool ZipkinSharedRpcSpan { get; private set; }
+            public ISampler Sampler { get; private set; }
+            public IReporter Reporter { get; private set; }
+            public IClock Clock { get; private set; } = new SystemClock();
+            public IScopeManager ScopeManager { get; private set; } = new AsyncLocalScopeManager();
+            public bool ExpandExceptionLogs { get; private set; }
+            public bool UseTraceId128Bit { get; private set; }
+            public IReadOnlyDictionary<string, object> Tags => _tags;
+
             public Builder(string serviceName)
             {
-                _serviceName = CheckValidServiceName(serviceName);
+                ServiceName = CheckValidServiceName(serviceName);
 
                 _registryActions.Add(registry =>
                 {
@@ -229,19 +231,19 @@ public Builder(string serviceName)
 
             public Builder WithLoggerFactory(ILoggerFactory loggerFactory)
             {
-                _loggerFactory = loggerFactory;
+                LoggerFactory = loggerFactory;
                 return this;
             }
 
             public Builder WithReporter(IReporter reporter)
             {
-                _reporter = reporter;
+                Reporter = reporter;
                 return this;
             }
 
             public Builder WithSampler(ISampler sampler)
             {
-                _sampler = sampler;
+                Sampler = sampler;
                 return this;
             }
             public Builder RegisterInjector<TCarrier>(IFormat<TCarrier> format, Injector<TCarrier> injector)
@@ -264,43 +266,43 @@ public Builder RegisterCodec<TCarrier>(IFormat<TCarrier> format, Codec<TCarrier>
 
             public Builder WithMetrics(IMetrics metrics)
             {
-                _metrics = metrics;
+                Metrics = metrics;
                 return this;
             }
 
             public Builder WithMetricsFactory(IMetricsFactory factory)
             {
-                _metrics = new MetricsImpl(factory);
+                Metrics = new MetricsImpl(factory);
                 return this;
             }
 
             public Builder WithScopeManager(IScopeManager scopeManager)
             {
-                _scopeManager = scopeManager;
+                ScopeManager = scopeManager;
                 return this;
             }
 
             public Builder WithClock(IClock clock)
             {
-                _clock = clock;
+                Clock = clock;
                 return this;
             }
 
             public Builder WithZipkinSharedRpcSpan()
             {
-                _zipkinSharedRpcSpan = true;
+                ZipkinSharedRpcSpan = true;
                 return this;
             }
 
             public Builder WithExpandExceptionLogs()
             {
-                _expandExceptionLogs = true;
+                ExpandExceptionLogs = true;
                 return this;
             }
 
             public Builder WithTraceId128Bit()
             {
-                _useTraceId128Bit = true;
+                UseTraceId128Bit = true;
                 return this;
             }
 
@@ -342,45 +344,45 @@ public Builder WithTags(IEnumerable<KeyValuePair<string, string>> tags)
 
             public Builder WithBaggageRestrictionManager(IBaggageRestrictionManager baggageRestrictionManager)
             {
-                _baggageRestrictionManager = baggageRestrictionManager;
+                BaggageRestrictionManager = baggageRestrictionManager;
                 return this;
             }
 
             public Tracer Build()
             {
-                if (_loggerFactory == null)
+                if (LoggerFactory == null)
                 {
-                    _loggerFactory = NullLoggerFactory.Instance;
+                    LoggerFactory = NullLoggerFactory.Instance;
                 }
 
-                _registry = new PropagationRegistry(_loggerFactory);
+                _registry = new PropagationRegistry(LoggerFactory);
                 foreach (var configureRegistry in _registryActions)
                 {
                     configureRegistry(_registry);
                 }
 
-                if (_metrics == null)
+                if (Metrics == null)
                 {
-                    _metrics = new MetricsImpl(NoopMetricsFactory.Instance);
+                    Metrics = new MetricsImpl(NoopMetricsFactory.Instance);
                 }
 
-                if (_reporter == null)
+                if (Reporter == null)
                 {
-                    _reporter = new RemoteReporter.Builder()
-                        .WithLoggerFactory(_loggerFactory)
-                        .WithMetrics(_metrics)
+                    Reporter = new RemoteReporter.Builder()
+                        .WithLoggerFactory(LoggerFactory)
+                        .WithMetrics(Metrics)
                         .Build();
                 }
-                if (_sampler == null)
+                if (Sampler == null)
                 {
-                    _sampler = new RemoteControlledSampler.Builder(_serviceName)
-                        .WithLoggerFactory(_loggerFactory)
-                        .WithMetrics(_metrics)
+                    Sampler = new RemoteControlledSampler.Builder(ServiceName)
+                        .WithLoggerFactory(LoggerFactory)
+                        .WithMetrics(Metrics)
                         .Build();
                 }
 
-                return new Tracer(_serviceName, _reporter, _sampler, _registry, _clock, _metrics, _loggerFactory,
-                    _tags, _zipkinSharedRpcSpan, _scopeManager, _baggageRestrictionManager, _expandExceptionLogs, _useTraceId128Bit);
+                return new Tracer(ServiceName, Reporter, Sampler, _registry, Clock, Metrics, LoggerFactory,
+                    _tags, ZipkinSharedRpcSpan, ScopeManager, BaggageRestrictionManager, ExpandExceptionLogs, UseTraceId128Bit);
             }
 
             public static String CheckValidServiceName(String serviceName)

test/Jaeger.Tests/ConfigurationTests.cs

@@ -492,7 +492,7 @@ public void TestConstSampler()
         {
             SamplerConfiguration samplerConfiguration = new SamplerConfiguration(_loggerFactory)
                 .WithType(ConstSampler.Type);
-            ISampler sampler = samplerConfiguration.CreateSampler("name",
+            ISampler sampler = samplerConfiguration.GetSampler("name",
                 new MetricsImpl(NoopMetricsFactory.Instance));
             Assert.True(sampler is ConstSampler);
         }
@@ -502,7 +502,7 @@ public void TestProbabilisticSampler()
         {
             SamplerConfiguration samplerConfiguration = new SamplerConfiguration(_loggerFactory)
                 .WithType(ProbabilisticSampler.Type);
-            ISampler sampler = samplerConfiguration.CreateSampler("name",
+            ISampler sampler = samplerConfiguration.GetSampler("name",
                 new MetricsImpl(NoopMetricsFactory.Instance));
             Assert.True(sampler is ProbabilisticSampler);
         }
@@ -512,7 +512,7 @@ public void TestRateLimitingSampler()
         {
             SamplerConfiguration samplerConfiguration = new SamplerConfiguration(_loggerFactory)
                 .WithType(RateLimitingSampler.Type);
-            ISampler sampler = samplerConfiguration.CreateSampler("name",
+            ISampler sampler = samplerConfiguration.GetSampler("name",
                 new MetricsImpl(NoopMetricsFactory.Instance));
             Assert.True(sampler is RateLimitingSampler);
         }