Add tracing-config

dropwizard-servers/build.gradle

@@ -5,6 +5,7 @@ apply from: "${rootDir}/gradle/publish.gradle"
 dependencies {
     compile project(":error-handling")
     compile project(":ext:brave-extensions")
+    compile project(":tracing-config")
 
     compile "com.fasterxml.jackson.core:jackson-databind"
     compile "com.google.code.findbugs:jsr305"

dropwizard-servers/src/main/java/com/palantir/remoting1/servers/BraveBundle.java

@@ -18,14 +18,18 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.MetricRegistry;
 import com.github.kristofa.brave.Brave;
 import com.github.kristofa.brave.InheritableServerClientAndLocalSpanState;
 import com.github.kristofa.brave.Sampler;
 import com.github.kristofa.brave.ServerRequestInterceptor;
 import com.github.kristofa.brave.ServerResponseInterceptor;
 import com.github.kristofa.brave.SpanCollector;
+import com.github.kristofa.brave.SpanCollectorMetricsHandler;
 import com.github.kristofa.brave.ext.SlfLoggingSpanCollector;
 import com.github.kristofa.brave.http.HttpRequest;
+import com.github.kristofa.brave.http.HttpSpanCollector;
 import com.github.kristofa.brave.http.SpanNameProvider;
 import com.github.kristofa.brave.jaxrs2.BraveContainerRequestFilter;
 import com.github.kristofa.brave.jaxrs2.BraveContainerResponseFilter;
@@ -34,8 +38,11 @@
 import com.google.common.base.Strings;
 import com.google.common.base.Supplier;
 import com.google.common.net.InetAddresses;
-import com.palantir.remoting1.servers.config.TracingConfig;
-import com.palantir.remoting1.servers.config.TracingConfigProvider;
+import com.palantir.tracing1.config.HttpReporterConfig;
+import com.palantir.tracing1.config.LogReporterConfig;
+import com.palantir.tracing1.config.ReporterTypeConfig;
+import com.palantir.tracing1.config.TracingConfig;
+import com.palantir.tracing1.config.TracingConfigProvider;
 import com.twitter.zipkin.gen.Endpoint;
 import io.dropwizard.Configuration;
 import io.dropwizard.jetty.ConnectorFactory;
@@ -51,14 +58,16 @@
 import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nullable;
 import javax.servlet.DispatcherType;
+import zipkin.Span;
+import zipkin.reporter.Reporter;
 
 public final class BraveBundle<C extends Configuration & TracingConfigProvider> extends AbstractConfiguredBundle<C> {
 
     private final AtomicReference<Brave> braveRef = new AtomicReference<>();
 
     @Override
     protected void start(C configuration, Environment environment) throws Exception {
-        Brave brave = createBrave(configuration);
+        Brave brave = createBrave(configuration, environment);
         this.braveRef.set(brave);
         registerTracers(environment, brave);
         log().info("Registered Brave tracer {}", brave);
@@ -70,34 +79,61 @@ public Brave brave() {
         return brave;
     }
 
-    private Brave createBrave(C config) {
+    private Brave createBrave(C config, final Environment environment) {
         // TODO(rfink) Is there a more stable way to retrieve IP/Port information?
-        Endpoint endpoint = Endpoint.builder()
-                .serviceName(appName())
-                .ipv4(extractIp(config))
-                .port(extractPort(config))
-                .build();
+        Endpoint endpoint = getEndpoint(config);
+        Brave.Builder builder = new Brave.Builder(new InheritableServerClientAndLocalSpanState(endpoint));
 
+        Optional<TracingConfig> maybeTracingConfig = config.maybeTracingConfig();
+        builder.traceSampler(getSampler(maybeTracingConfig));
+
+        Reporter<Span> reporter = getReporter(maybeTracingConfig);
+        if (reporter != null) {
+            builder.reporter(reporter);
+        } else {
+            builder.spanCollector(getSpanCollector(environment, maybeTracingConfig));
+        }
+
+        log().info("Starting tracing for {}", appName());
+        return builder.build();
+    }
+
+    private Reporter<Span> getReporter(Optional<TracingConfig> maybeTracingConfig) {
         // TODO (davids) use reporter instead
-        SpanCollector spanCollector;
-        Sampler sampler;
+        return null;
+    }
 
-        Optional<TracingConfig> maybeTracingConfig = config.maybeTracingConfig();
+    private Endpoint getEndpoint(C config) {
+        return Endpoint.builder()
+                    .serviceName(appName())
+                    .ipv4(extractIp(config))
+                    .port(extractPort(config))
+                    .build();
+    }
+
+    private SpanCollector getSpanCollector(Environment environment, Optional<TracingConfig> maybeTracingConfig) {
         if (maybeTracingConfig.isPresent()) {
-            TracingConfig tracingConfig = maybeTracingConfig.get();
-            sampler = tracingConfig.sampler().sampler();
-            spanCollector = tracingConfig.reporter().reporter();
-        } else {
-            log().warn("Tracing configuration not specified for {}", appName());
-            sampler = Sampler.ALWAYS_SAMPLE;
-            spanCollector = new SlfLoggingSpanCollector("tracing." + appName());
+            ReporterTypeConfig reporterTypeConfig = maybeTracingConfig.get().reporter();
+            if (reporterTypeConfig instanceof HttpReporterConfig) {
+                HttpReporterConfig httpReporterConfig = (HttpReporterConfig) reporterTypeConfig;
+                // TODO (davids) URLConnectionSender
+                return HttpSpanCollector.create(httpReporterConfig.url(),
+                        new DropwizardMetricsHandler(environment));
+            } else if (reporterTypeConfig instanceof LogReporterConfig) {
+                return new SlfLoggingSpanCollector(((LogReporterConfig) reporterTypeConfig).logger());
+            }
         }
+        String loggerName = "tracing." + appName();
+        log().warn("Tracing reporter not specified, defaulting to logging spans to '{}'", loggerName);
+        return new SlfLoggingSpanCollector(loggerName);
+    }
 
-        log().info("Starting tracer for {} writing to {}", appName(), spanCollector);
-        return new Brave.Builder(new InheritableServerClientAndLocalSpanState(endpoint))
-                .traceSampler(sampler)
-                .spanCollector(spanCollector)
-                .build();
+    private Sampler getSampler(Optional<TracingConfig> maybeTracingConfig) {
+        if (maybeTracingConfig.isPresent()) {
+            return Sampler.create(maybeTracingConfig.get().sampler().probability());
+        }
+        log().warn("Tracing sampler not specified, defaulting to always sampling");
+        return Sampler.ALWAYS_SAMPLE;
     }
 
     /**
@@ -271,4 +307,26 @@ static Optional<ConnectorFactory> extractConnector(Configuration config, int num
             return Optional.absent();
         }
     }
+
+    private static class DropwizardMetricsHandler implements SpanCollectorMetricsHandler {
+        private final Counter accepted;
+        private final Counter dropped;
+
+        DropwizardMetricsHandler(Environment environment) {
+            this.accepted = environment.metrics().counter(
+                    MetricRegistry.name(BraveBundle.class, "accepted"));
+            this.dropped = environment.metrics().counter(
+                    MetricRegistry.name(BraveBundle.class, "dropped"));
+        }
+
+        @Override
+        public void incrementAcceptedSpans(int quantity) {
+            accepted.inc(quantity);
+        }
+
+        @Override
+        public void incrementDroppedSpans(int quantity) {
+            dropped.inc(quantity);
+        }
+    }
 }

dropwizard-servers/src/main/java/com/palantir/remoting1/servers/HttpRemotingBundle.java

@@ -19,7 +19,7 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.github.kristofa.brave.Brave;
-import com.palantir.remoting1.servers.config.TracingConfigProvider;
+import com.palantir.tracing1.config.TracingConfigProvider;
 import io.dropwizard.Configuration;
 import io.dropwizard.setup.Bootstrap;
 import io.dropwizard.setup.Environment;

dropwizard-servers/src/test/java/com/palantir/remoting1/servers/TestConfiguration.java

@@ -18,8 +18,8 @@
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Optional;
-import com.palantir.remoting1.servers.config.TracingConfig;
-import com.palantir.remoting1.servers.config.TracingConfigProvider;
+import com.palantir.tracing1.config.TracingConfig;
+import com.palantir.tracing1.config.TracingConfigProvider;
 import io.dropwizard.Configuration;
 
 public final class TestConfiguration extends Configuration implements TracingConfigProvider {

jaxrs-clients/src/test/java/com/palantir/remoting1/jaxrs/feignimpl/TestConfiguration.java

@@ -18,8 +18,8 @@
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Optional;
-import com.palantir.remoting1.servers.config.TracingConfig;
-import com.palantir.remoting1.servers.config.TracingConfigProvider;
+import com.palantir.tracing1.config.TracingConfig;
+import com.palantir.tracing1.config.TracingConfigProvider;
 import io.dropwizard.Configuration;
 
 public class TestConfiguration extends Configuration implements TracingConfigProvider {

settings.gradle

@@ -11,3 +11,4 @@ include 'retrofit2-clients'
 include 'service-config'
 include 'ssl-config'
 include 'tracing'
+include 'tracing-config'

tracing-config/build.gradle

@@ -0,0 +1,13 @@
+apply plugin: "org.inferred.processors"
+apply from: "${rootDir}/gradle/publish.gradle"
+
+dependencies {
+    compile "com.fasterxml.jackson.core:jackson-databind"
+    compile "com.google.guava:guava"
+
+    testCompile "junit:junit"
+    testCompile "org.hamcrest:hamcrest-all"
+    testCompile "org.mockito:mockito-core"
+
+    processor "org.immutables:value"
+}

dropwizard-servers/src/main/java/com/palantir/remoting1/servers/config/HttpReporterConfig.java → tracing-config/src/main/java/com/palantir/tracing1/config/HttpReporterConfig.java

@@ -14,17 +14,13 @@
  * limitations under the License.
  */
 
-package com.palantir.remoting1.servers.config;
+package com.palantir.tracing1.config;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-import com.github.kristofa.brave.SpanCollector;
-import com.github.kristofa.brave.SpanCollectorMetricsHandler;
-import com.github.kristofa.brave.http.HttpSpanCollector;
+import java.net.MalformedURLException;
+import java.net.URL;
 import org.immutables.value.Value;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /** Configuration options for Reporter. */
 @Value.Immutable
@@ -33,40 +29,22 @@
 @JsonSerialize(as = ImmutableHttpReporterConfig.class)
 @SuppressWarnings("checkstyle:designforextension")
 public abstract class HttpReporterConfig implements ReporterTypeConfig {
-    private static final Logger log = LoggerFactory.getLogger(HttpReporterConfig.class);
 
     @Value.Default
     public String type() {
         return "http";
     }
 
     @Value.Parameter
-    protected abstract String url();
-
-    @JsonIgnore
-    @Value.Default
-    protected SpanCollectorMetricsHandler metrics() {
-        return new SpanCollectorMetricsHandler() {
-            @Override
-            public void incrementAcceptedSpans(int quantity) {
-                if (log.isTraceEnabled()) {
-                    log.trace("Accepted {} trace spans", quantity);
-                }
-            }
-
-            @Override
-            public void incrementDroppedSpans(int quantity) {
-                if (log.isInfoEnabled()) {
-                    log.info("Dropped {} trace spans", quantity);
-                }
-            }
-        };
-    }
-
-    @Override
-    @JsonIgnore
-    public final SpanCollector reporter() {
-        return HttpSpanCollector.create(url(), metrics());
+    public abstract String url();
+
+    @Value.Check
+    void check() {
+        try {
+            new URL(url());
+        } catch (MalformedURLException e) {
+            throw new IllegalArgumentException(String.format("URL '%s' is not valid", url()));
+        }
     }
 
     public static Builder builder() {

dropwizard-servers/src/main/java/com/palantir/remoting1/servers/config/Slf4jReporterConfig.java → tracing-config/src/main/java/com/palantir/tracing1/config/LogReporterConfig.java

@@ -14,22 +14,21 @@
  * limitations under the License.
  */
 
-package com.palantir.remoting1.servers.config;
+package com.palantir.tracing1.config;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-import com.github.kristofa.brave.SpanCollector;
-import com.github.kristofa.brave.ext.SlfLoggingSpanCollector;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
 import org.immutables.value.Value;
 
 /** Configuration options for logging reporter. */
 @Value.Immutable
 @Value.Style(visibility = Value.Style.ImplementationVisibility.PACKAGE)
-@JsonDeserialize(as = ImmutableSlf4jReporterConfig.class)
-@JsonSerialize(as = ImmutableSlf4jReporterConfig.class)
+@JsonDeserialize(as = ImmutableLogReporterConfig.class)
+@JsonSerialize(as = ImmutableLogReporterConfig.class)
 @SuppressWarnings("checkstyle:designforextension")
-public abstract class Slf4jReporterConfig implements ReporterTypeConfig {
+public abstract class LogReporterConfig implements ReporterTypeConfig {
 
     @Value.Default
     public String type() {
@@ -41,15 +40,14 @@ public String logger() {
         return "tracing";
     }
 
-    @Override
-    @JsonIgnore
-    public final SpanCollector reporter() {
-        return new SlfLoggingSpanCollector(logger());
+    @Value.Check
+    void check() {
+        Preconditions.checkArgument(!Strings.isNullOrEmpty(logger()), "Logger cannot be null or empty");
     }
 
     public static Builder builder() {
         return new Builder();
     }
 
-    public static final class Builder extends ImmutableSlf4jReporterConfig.Builder {}
+    public static final class Builder extends ImmutableLogReporterConfig.Builder {}
 }

dropwizard-servers/src/main/java/com/palantir/remoting1/servers/config/ReporterConfig.java → tracing-config/src/main/java/com/palantir/tracing1/config/ReporterConfig.java

@@ -14,14 +14,10 @@
  * limitations under the License.
  */
 
-package com.palantir.remoting1.servers.config;
+package com.palantir.tracing1.config;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-import com.github.kristofa.brave.SpanCollector;
-import com.github.kristofa.brave.ext.SlfLoggingSpanCollector;
-import com.google.common.base.Preconditions;
 import org.immutables.value.Value;
 
 /** Configuration options for Reporter. */
@@ -37,17 +33,6 @@ public String type() {
         return "log";
     }
 
-    @Value.Check
-    public void check() {
-        Preconditions.checkArgument(type().equals("slf4j"),
-                "Invalid type %s", type());
-    }
-
-    @JsonIgnore
-    public final SpanCollector reporter() {
-        return new SlfLoggingSpanCollector("tracing");
-    }
-
     public static Builder builder() {
         return new Builder();
     }