diff --git a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/server/GeronimoOpenTracingFeature.java b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/server/GeronimoOpenTracingFeature.java
index 73c7f28..dbf197a 100644
--- a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/server/GeronimoOpenTracingFeature.java
+++ b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/server/GeronimoOpenTracingFeature.java
@@ -88,6 +88,7 @@
         final String path = Stream.of(
                 ofNullable(resourceInfo.getResourceClass().getAnnotation(Path.class)).map(Path::value).orElse(""),
                 ofNullable(resourceInfo.getResourceMethod().getAnnotation(Path.class)).map(Path::value).orElse(""))
+                .map(it -> it.equals("/") ? "" : it)
                 .map(it -> it.substring(it.startsWith("/") ? 1 : 0, it.endsWith("/") ? it.length() - 1 : it.length()))
                 .filter(it -> !it.isEmpty())
                 .collect(joining("/", "/", ""));
diff --git a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinConverter.java b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinConverter.java
index 195cff8..4238844 100644
--- a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinConverter.java
+++ b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinConverter.java
@@ -50,6 +50,7 @@
     private IdGenerator idGenerator;
 
     private String serviceName;
+    private boolean useV2 = false;
 
     public void setZipkinSpanEvent(final Bus<ZipkinSpan> zipkinSpanEvent) {
         this.zipkinSpanEvent = zipkinSpanEvent;
@@ -65,6 +66,7 @@
 
     public void init() {
         serviceName = config.read("zipkin.serviceName", getHostName() + "_" + getPid());
+        useV2 = Boolean.parseBoolean(config.read("span.converter.zipkin.http.useV2", "false").trim());
     }
 
     @Override
@@ -91,7 +93,14 @@
     private ZipkinSpan toZipkin(final SpanImpl span) {
         final ZipkinSpan.ZipkinEndpoint endpoint = toEndpoint(span);
 
-        final ZipkinSpan zipkin = new ZipkinSpan();
+        final ZipkinSpan zipkin;
+        if (useV2) {
+            zipkin = new ZipkinSpan();
+        } else {
+            zipkin = new ZipkinV1Span();
+            ((ZipkinV1Span) zipkin).setBinaryAnnotations(toBinaryAnnotations(span.getTags()));
+        }
+
         if (idGenerator.isCounter()) {
             zipkin.setParentId(asLong(span.getParentId()));
             zipkin.setTraceId(asLong(span.getTraceId()));
@@ -106,7 +115,7 @@
         zipkin.setTimestamp(span.getTimestamp());
         zipkin.setDuration(span.getDuration());
         zipkin.setAnnotations(toAnnotations(span));
-        zipkin.setBinaryAnnotations(toBinaryAnnotations(span.getTags()));
+
         zipkin.setTags(span.getTags().entrySet().stream().filter(e -> !Tags.SPAN_KIND.getKey().equalsIgnoreCase(e.getKey()))
                 .collect(toMap(Map.Entry::getKey, e -> String.valueOf(e.getValue()))));
 
diff --git a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinHttp.java b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinHttp.java
index 2301e68..ca43c3c 100644
--- a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinHttp.java
+++ b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinHttp.java
@@ -22,6 +22,7 @@
 import static java.util.concurrent.TimeUnit.MINUTES;
 import static javax.ws.rs.client.Entity.entity;
 import static javax.ws.rs.core.MediaType.APPLICATION_JSON_TYPE;
+import static javax.ws.rs.core.MediaType.MEDIA_TYPE_WILDCARD;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -38,6 +39,7 @@
 import javax.json.bind.JsonbBuilder;
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
 
 import org.apache.geronimo.microprofile.opentracing.common.config.GeronimoOpenTracingConfig;
@@ -178,7 +180,7 @@
 
     private void doSend(final List<ZipkinSpan> copy) {
         final Response result = client.target(collector)
-                .request(APPLICATION_JSON_TYPE)
+                .request()
                 .post(entity(copy, APPLICATION_JSON_TYPE));
         if (result.getStatus() >= 300) {
             // todo: better handling but at least log them to not loose them completely or explode in memory
diff --git a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinSpan.java b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinSpan.java
index ba1a555..5a9ae63 100644
--- a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinSpan.java
+++ b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinSpan.java
@@ -30,7 +30,6 @@
     private ZipkinEndpoint localEndpoint;
     private ZipkinEndpoint remoteEndpoint;
     private List<ZipkinAnnotation> annotations;
-    private List<ZipkinBinaryAnnotation> binaryAnnotations;
     private Map<String, String> tags;
     private Boolean debug;
     private Boolean shared;
@@ -91,14 +90,6 @@
         this.annotations = annotations;
     }
 
-    public List<ZipkinBinaryAnnotation> getBinaryAnnotations() {
-        return binaryAnnotations;
-    }
-
-    public void setBinaryAnnotations(final List<ZipkinBinaryAnnotation> binaryAnnotations) {
-        this.binaryAnnotations = binaryAnnotations;
-    }
-
     public Boolean getDebug() {
         return debug;
     }
diff --git a/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinV1Span.java b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinV1Span.java
new file mode 100644
index 0000000..f89d00f
--- /dev/null
+++ b/geronimo-opentracing-common/src/main/java/org/apache/geronimo/microprofile/opentracing/common/microprofile/zipkin/ZipkinV1Span.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.geronimo.microprofile.opentracing.common.microprofile.zipkin;
+
+import java.util.List;
+
+public class ZipkinV1Span extends ZipkinSpan {
+    private List<ZipkinBinaryAnnotation> binaryAnnotations;
+
+    public List<ZipkinBinaryAnnotation> getBinaryAnnotations() {
+        return binaryAnnotations;
+    }
+
+    public void setBinaryAnnotations(final List<ZipkinBinaryAnnotation> binaryAnnotations) {
+        this.binaryAnnotations = binaryAnnotations;
+    }
+}
diff --git a/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/BasicZipkinTest.java b/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/BasicZipkinTest.java
index 14ce740..cda3dd1 100644
--- a/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/BasicZipkinTest.java
+++ b/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/BasicZipkinTest.java
@@ -23,17 +23,13 @@
 import org.jboss.arquillian.testng.Arquillian;
 import org.jboss.shrinkwrap.api.ShrinkWrap;
 import org.jboss.shrinkwrap.api.asset.ClassLoaderAsset;
-import org.jboss.shrinkwrap.api.asset.EmptyAsset;
 import org.jboss.shrinkwrap.api.spec.WebArchive;
-import org.jboss.shrinkwrap.descriptor.api.Descriptors;
 import org.junit.Ignore;
 import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.Test;
 import zipkin2.Span;
-import zipkin2.junit.ZipkinRule;
 
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.ClientBuilder;
@@ -73,6 +69,8 @@
         System.setProperty("geronimo.opentracing.span.converter.zipkin.http.maxSpansPerBulk", "1");
         System.setProperty("geronimo.opentracing.span.converter.zipkin.http.maxSpansIteration","1");
         System.setProperty("geronimo.opentracing.span.converter.zipkin.http.bufferSize","1");
+        System.setProperty("geronimo.opentracing.span.converter.zipkin.http.useV2","true");
+
     }
 
 
diff --git a/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/ZipkinRule.java b/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/ZipkinRule.java
new file mode 100644
index 0000000..08cda86
--- /dev/null
+++ b/geronimo-opentracing/src/test/java/org/apache/geronimo/microprofile/opentracing/tck/setup/ZipkinRule.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2015-2018 The OpenZipkin Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.apache.geronimo.microprofile.opentracing.tck.setup;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import okhttp3.HttpUrl;
+import okhttp3.mockwebserver.Dispatcher;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import okhttp3.mockwebserver.RecordedRequest;
+import okio.Buffer;
+import okio.GzipSource;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import zipkin2.Callback;
+import zipkin2.DependencyLink;
+import zipkin2.Span;
+import zipkin2.codec.SpanBytesDecoder;
+import zipkin2.collector.Collector;
+import zipkin2.collector.CollectorMetrics;
+import zipkin2.collector.InMemoryCollectorMetrics;
+import zipkin2.internal.Nullable;
+import zipkin2.internal.Platform;
+import zipkin2.junit.HttpFailure;
+import zipkin2.storage.InMemoryStorage;
+import zipkin2.storage.StorageComponent;
+
+import static okhttp3.mockwebserver.SocketPolicy.KEEP_OPEN;
+
+/**
+ * Starts up a local Zipkin server, listening for http requests on {@link #httpUrl}.
+ *
+ * <p>This can be used to test instrumentation. For example, you can POST spans directly to this
+ * server.
+ *
+ * <p>See http://openzipkin.github.io/zipkin-api/#/
+ */
+public final class ZipkinRule implements TestRule {
+    private final InMemoryStorage storage = InMemoryStorage.newBuilder().build();
+    private final InMemoryCollectorMetrics metrics = new InMemoryCollectorMetrics();
+    private final MockWebServer server = new MockWebServer();
+    private final BlockingQueue<MockResponse> failureQueue = new LinkedBlockingQueue<>();
+    private final AtomicInteger receivedSpanBytes = new AtomicInteger();
+
+    public ZipkinRule() {
+        Dispatcher dispatcher =
+                new Dispatcher() {
+                    final ZipkinDispatcher successDispatch = new ZipkinDispatcher(storage, metrics, server);
+
+                    @Override
+                    public MockResponse dispatch(RecordedRequest request) {
+                        MockResponse maybeFailure = failureQueue.poll();
+                        if (maybeFailure != null) return maybeFailure;
+                        MockResponse result = successDispatch.dispatch(request);
+                        if (request.getMethod().equals("POST")) {
+                            receivedSpanBytes.addAndGet((int) request.getBodySize());
+                        }
+                        return result;
+                    }
+
+                    @Override
+                    public MockResponse peek() {
+                        MockResponse maybeFailure = failureQueue.peek();
+                        if (maybeFailure != null) return maybeFailure.clone();
+                        return new MockResponse().setSocketPolicy(KEEP_OPEN);
+                    }
+                };
+        server.setDispatcher(dispatcher);
+    }
+
+    /** Use this to connect. The zipkin v1 interface will be under "/api/v1" */
+    public String httpUrl() {
+        return String.format("http://%s:%s", server.getHostName(), server.getPort());
+    }
+
+    /** Use this to see how many requests you've sent to any zipkin http endpoint. */
+    public int httpRequestCount() {
+        return server.getRequestCount();
+    }
+
+    /** Use this to see how many spans or serialized bytes were collected on the http endpoint. */
+    public InMemoryCollectorMetrics collectorMetrics() {
+        return metrics;
+    }
+
+    /** Retrieves all traces this zipkin server has received. */
+    public List<List<Span>> getTraces() {
+        return storage.spanStore().getTraces();
+    }
+
+    /** Retrieves a trace by ID which zipkin server has received, or null if not present. */
+    @Nullable
+    public List<Span> getTrace(String traceId) {
+        try {
+            return storage.spanStore().getTrace(traceId).execute();
+        } catch (IOException e) {
+            throw Platform.get().assertionError("I/O exception in in-memory storage", e);
+        }
+    }
+
+    /** Retrieves all service links between traces this zipkin server has received. */
+    public List<DependencyLink> getDependencies() {
+        return storage.spanStore().getDependencies();
+    }
+
+    /**
+     * Used to manually start the server.
+     *
+     * @param httpPort choose 0 to select an available port
+     */
+    public void start(int httpPort) throws IOException {
+        server.start(httpPort);
+    }
+
+    /** Used to manually stop the server. */
+    public void shutdown() throws IOException {
+        server.shutdown();
+    }
+
+    @Override
+    public Statement apply(Statement base, Description description) {
+        return server.apply(base, description);
+    }
+
+    final class ZipkinDispatcher extends Dispatcher {
+        private final Collector consumer;
+        private final CollectorMetrics metrics;
+        private final MockWebServer server;
+
+        ZipkinDispatcher(StorageComponent storage, CollectorMetrics metrics, MockWebServer server) {
+            this.consumer = Collector.newBuilder(getClass()).storage(storage).metrics(metrics).build();
+            this.metrics = metrics;
+            this.server = server;
+        }
+
+        @Override
+        public MockResponse dispatch(RecordedRequest request) {
+            HttpUrl url = server.url(request.getPath());
+            if (request.getMethod().equals("POST")) {
+                String type = request.getHeader("Content-Type");
+                if (url.encodedPath().equals("/api/v1/spans")) {
+                    SpanBytesDecoder decoder =
+                            type != null && type.contains("/x-thrift")
+                                    ? SpanBytesDecoder.THRIFT
+                                    : SpanBytesDecoder.JSON_V1;
+
+                    return acceptSpans(request, decoder);
+                } else if (url.encodedPath().equals("/api/v2/spans")) {
+                    SpanBytesDecoder decoder =
+                            type != null && type.contains("/x-protobuf")
+                                    ? SpanBytesDecoder.PROTO3
+                                    : SpanBytesDecoder.JSON_V2;
+
+                    return acceptSpans(request, decoder);
+                }
+            } else { // unsupported method
+                return new MockResponse().setResponseCode(405);
+            }
+            return new MockResponse().setResponseCode(404);
+        }
+
+        MockResponse acceptSpans(RecordedRequest request, SpanBytesDecoder decoder) {
+            metrics.incrementMessages();
+            byte[] body = request.getBody().readByteArray();
+
+            // check for the presence of binaryAnnotations, which should not be present in V2.
+            // @see ZipkinHttpCollector.testForUnexpectedFormat
+            if (SpanBytesDecoder.JSON_V2.equals(decoder) &&
+                    new String(body).contains("\"binaryAnnotations\"")) {
+                final MockResponse mockResponse = new MockResponse();
+                mockResponse.setResponseCode(400);
+                mockResponse.setBody("Expected a JSON_V2 encoded list, but received: JSON_V1\n");
+                return mockResponse;
+            }
+
+            String encoding = request.getHeader("Content-Encoding");
+            if (encoding != null && encoding.contains("gzip")) {
+                try {
+                    Buffer result = new Buffer();
+                    GzipSource source = new GzipSource(new Buffer().write(body));
+                    while (source.read(result, Integer.MAX_VALUE) != -1) ;
+                    body = result.readByteArray();
+                } catch (IOException e) {
+                    metrics.incrementMessagesDropped();
+                    return new MockResponse().setResponseCode(400).setBody("Cannot gunzip spans");
+                }
+            }
+
+            final MockResponse result = new MockResponse();
+            consumer.acceptSpans(
+                    body,
+                    decoder,
+                    new Callback<Void>() {
+                        @Override
+                        public void onSuccess(Void value) {
+                            result.setResponseCode(202);
+                        }
+
+                        @Override
+                        public void onError(Throwable t) {
+                            String message = t.getMessage();
+                            result.setBody(message).setResponseCode(message.startsWith("Cannot store") ? 500 : 400);
+                        }
+                    });
+            return result;
+        }
+    }
+
+}