Using FromIConfiguration throughout complete cascade (jaegertracing#138)

Author: Falco20019

src/Jaeger/Configuration.cs

@@ -162,11 +162,11 @@ public static Configuration FromIConfiguration(ILoggerFactory loggerFactory, ICo
             ILogger logger = loggerFactory.CreateLogger<Configuration>();
 
             return new Configuration(GetProperty(JaegerServiceName, configuration), loggerFactory)
-                .WithTracerTags(TracerTagsFromEnv(logger, configuration))
+                .WithTracerTags(TracerTagsFromIConfiguration(logger, configuration))
                 .WithTraceId128Bit(GetPropertyAsBool(JaegerTraceId128Bit, logger, configuration).GetValueOrDefault(false))
-                .WithReporter(ReporterConfiguration.FromEnv(loggerFactory))
-                .WithSampler(SamplerConfiguration.FromEnv(loggerFactory))
-                .WithCodec(CodecConfiguration.FromEnv(loggerFactory));
+                .WithReporter(ReporterConfiguration.FromIConfiguration(loggerFactory, configuration))
+                .WithSampler(SamplerConfiguration.FromIConfiguration(loggerFactory, configuration))
+                .WithCodec(CodecConfiguration.FromIConfiguration(loggerFactory, configuration));
         }
 
         /// <summary>
@@ -519,7 +519,7 @@ public static ReporterConfiguration FromIConfiguration(ILoggerFactory loggerFact
                     .WithLogSpans(GetPropertyAsBool(JaegerReporterLogSpans, logger, configuration).GetValueOrDefault(false))
                     .WithFlushInterval(GetPropertyAsTimeSpan(JaegerReporterFlushInterval, logger, configuration))
                     .WithMaxQueueSize(GetPropertyAsInt(JaegerReporterMaxQueueSize, logger, configuration))
-                    .WithSender(SenderConfiguration.FromEnv(loggerFactory));
+                    .WithSender(SenderConfiguration.FromIConfiguration(loggerFactory, configuration));
             }
 
             /// <summary>
@@ -819,7 +819,7 @@ private static string GetProperty(string name, IConfiguration configuration)
             return null;
         }
 
-        private static Dictionary<string, string> TracerTagsFromEnv(ILogger logger, IConfiguration configuration)
+        private static Dictionary<string, string> TracerTagsFromIConfiguration(ILogger logger, IConfiguration configuration)
         {
             Dictionary<string, string> tracerTagMaps = null;
             string tracerTags = GetProperty(JaegerTags, configuration);

test/Jaeger.Tests/ConfigurationTests.cs

@@ -100,7 +100,7 @@ public void TestFromIConfig()
         }
 
         [Fact]
-        public void TestSamplerConst()
+        public void TestSamplerConstFromEnv()
         {
             SetProperty(Configuration.JaegerSamplerType, ConstSampler.Type);
             SetProperty(Configuration.JaegerSamplerParam, "1");
@@ -138,7 +138,7 @@ public void TestSamplerConstInvalidParam()
         }
 
         [Fact]
-        public void TestReporterConfiguration()
+        public void TestReporterConfigurationFromEnv()
         {
             SetProperty(Configuration.JaegerReporterLogSpans, "true");
             SetProperty(Configuration.JaegerAgentHost, "MyHost");
@@ -153,28 +153,38 @@ public void TestReporterConfiguration()
             Assert.Equal(1000, reporterConfig.MaxQueueSize);
         }
 
-        [Fact]
-        public void TestReporterConfigurationInvalidFlushInterval()
-        {
-            SetProperty(Configuration.JaegerReporterFlushInterval, "X");
-            ReporterConfiguration reporterConfig = ReporterConfiguration.FromEnv(_loggerFactory);
-            Assert.Null(reporterConfig.FlushInterval);
-        }
-
         [Fact]
         public void TestReporterConfigurationFromIConfiguration()
         {
             var arrayDict = new Dictionary<string, string>
             {
-                {Configuration.JaegerReporterLogSpans, "X"},
+                {Configuration.JaegerSamplerType, ConstSampler.Type},
+                {Configuration.JaegerSamplerParam, "1"},
+                {Configuration.JaegerReporterLogSpans, "true"},
+                {Configuration.JaegerAgentHost, "MyHost"},
+                {Configuration.JaegerAgentPort, "1234"},
+                {Configuration.JaegerReporterFlushInterval, "500"},
+                {Configuration.JaegerReporterMaxQueueSize, "1000"}
             };
 
             var configuration = new ConfigurationBuilder()
                 .AddInMemoryCollection(arrayDict)
                 .Build();
 
             ReporterConfiguration reporterConfig = ReporterConfiguration.FromIConfiguration(_loggerFactory, configuration);
-            Assert.False(reporterConfig.LogSpans);
+            Assert.True(reporterConfig.LogSpans);
+            Assert.Equal("MyHost", reporterConfig.SenderConfig.AgentHost);
+            Assert.Equal(1234, reporterConfig.SenderConfig.AgentPort);
+            Assert.Equal(TimeSpan.FromMilliseconds(500), reporterConfig.FlushInterval);
+            Assert.Equal(1000, reporterConfig.MaxQueueSize);
+        }
+
+        [Fact]
+        public void TestReporterConfigurationInvalidFlushInterval()
+        {
+            SetProperty(Configuration.JaegerReporterFlushInterval, "X");
+            ReporterConfiguration reporterConfig = ReporterConfiguration.FromEnv(_loggerFactory);
+            Assert.Null(reporterConfig.FlushInterval);
         }
 
         [Fact]