BREAKING CHANGE: Remove shaded dependencies and use HttpClient interface

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>github-client</artifactId>
-    <version>0.3.12-SNAPSHOT</version>
+    <version>0.4.0-SNAPSHOT</version>
 
     <parent>
         <groupId>com.spotify</groupId>
@@ -86,8 +86,6 @@
         <opencensus.version>0.31.1</opencensus.version>
         <okhttp.version>4.11.0</okhttp.version>
         <opentelemetry.version>1.42.1</opentelemetry.version>
-
-        <shade.id>${project.groupId}.githubclient.shade</shade.id>
     </properties>
 
     <dependencyManagement>
@@ -474,38 +472,6 @@
                     </sourceDirectories>
                 </configuration>
             </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.3</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <artifactSet>
-                                <includes>
-                                    <include>${project.groupId}:${project.artifactId}</include>
-                                    <include>com.squareup.okhttp3</include>
-                                    <include>com.squareup.okio</include>
-                                </includes>
-                            </artifactSet>
-                            <relocations>
-                                <relocation>
-                                    <pattern>okhttp3</pattern>
-                                    <shadedPattern>${shade.id}.okhttp3</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>okio</pattern>
-                                    <shadedPattern>${shade.id}.okio</shadedPattern>
-                                </relocation>
-                            </relocations>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>

src/main/java/com/spotify/github/http/HttpClient.java

@@ -0,0 +1,29 @@
+/*-
+ * -\-\-
+ * github-api
+ * --
+ * Copyright (C) 2021 Spotify AB
+ * --
+ * 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 com.spotify.github.http;
+
+import com.spotify.github.tracing.Tracer;
+import java.util.concurrent.CompletableFuture;
+
+public interface HttpClient {
+  CompletableFuture<HttpResponse> send(HttpRequest request);
+  void setTracer(Tracer tracer);
+}

src/main/java/com/spotify/github/http/HttpRequest.java

@@ -0,0 +1,43 @@
+/*-
+ * -\-\-
+ * github-api
+ * --
+ * Copyright (C) 2021 Spotify AB
+ * --
+ * 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 com.spotify.github.http;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.spotify.github.GithubStyle;
+import org.immutables.value.Value;
+
+import java.util.List;
+import java.util.Map;
+
+@Value.Immutable
+@GithubStyle
+@JsonSerialize(as = ImmutableHttpRequest.class)
+@JsonDeserialize(as = ImmutableHttpRequest.class)
+public interface HttpRequest {
+  String method();
+
+  String url();
+
+  String body();
+
+  Map<String, List<String>> headers();
+}

src/main/java/com/spotify/github/http/HttpResponse.java

@@ -0,0 +1,36 @@
+/*-
+ * -\-\-
+ * github-api
+ * --
+ * Copyright (C) 2021 Spotify AB
+ * --
+ * 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 com.spotify.github.http;
+
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+public interface HttpResponse {
+    HttpRequest request();
+    int statusCode();
+    String statusMessage();
+    InputStream body();
+    String bodyString();
+    Map<String, List<String>> headers();
+    boolean isSuccessful();
+    void close();
+}

src/main/java/com/spotify/github/http/okhttp/OkHttpHttpClient.java

@@ -0,0 +1,191 @@
+/*-
+ * -\-\-
+ * github-api
+ * --
+ * Copyright (C) 2021 Spotify AB
+ * --
+ * 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 com.spotify.github.http.okhttp;
+
+import static okhttp3.MediaType.parse;
+
+import com.spotify.github.http.HttpClient;
+import com.spotify.github.http.HttpRequest;
+import com.spotify.github.http.HttpResponse;
+import com.spotify.github.http.ImmutableHttpRequest;
+import com.spotify.github.tracing.NoopTracer;
+import com.spotify.github.tracing.Span;
+import com.spotify.github.tracing.TraceHelper;
+import com.spotify.github.tracing.Tracer;
+import com.spotify.github.tracing.opencensus.OpenCensusTracer;
+import com.spotify.github.tracing.opentelemetry.OpenTelemetryTracer;
+import io.opentelemetry.instrumentation.okhttp.v3_0.OkHttpTelemetry;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import okhttp3.*;
+import org.jetbrains.annotations.NotNull;
+
+public class OkHttpHttpClient implements HttpClient {
+  private final OkHttpClient client;
+  private Tracer tracer;
+  private Call.Factory callFactory;
+
+  public OkHttpHttpClient(final OkHttpClient client) {
+    this.client = client;
+    this.tracer = NoopTracer.INSTANCE;
+    this.callFactory = createTracedClient();
+  }
+
+  public OkHttpHttpClient(final OkHttpClient client, final Tracer tracer) {
+    this.client = client;
+    this.tracer = tracer;
+    this.callFactory = createTracedClient();
+  }
+
+  @Override
+  public CompletableFuture<HttpResponse> send(final HttpRequest httpRequest) {
+    Request request = buildRequest(httpRequest);
+    CompletableFuture<HttpResponse> future = new CompletableFuture<>();
+    try (Span span = tracer.span(httpRequest)) {
+      if (this.callFactory == null) {
+        this.callFactory = createTracedClient();
+      }
+      this.callFactory
+          .newCall(request)
+          .enqueue(
+              new Callback() {
+
+                @Override
+                public void onResponse(@NotNull final Call call, @NotNull final Response response)
+                    throws IOException {
+                  future.complete(new OkHttpHttpResponse(httpRequest, response));
+                }
+
+                @Override
+                public void onFailure(@NotNull final Call call, @NotNull final IOException e) {
+                  future.completeExceptionally(e);
+                }
+              });
+      tracer.attachSpanToFuture(span, future);
+    }
+    return future;
+  }
+
+  @Override
+  public void setTracer(final Tracer tracer) {
+    this.tracer = tracer;
+    this.callFactory = createTracedClient();
+  }
+
+  private Request buildRequest(final HttpRequest request) {
+    Request.Builder requestBuilder = new Request.Builder().url(request.url());
+    request
+        .headers()
+        .forEach(
+            (key, values) -> {
+              values.forEach(value -> requestBuilder.addHeader(key, value));
+            });
+    if (request.method().equals("GET")) {
+      requestBuilder.get();
+    } else {
+      requestBuilder.method(
+          request.method(),
+          RequestBody.create(parse(javax.ws.rs.core.MediaType.APPLICATION_JSON), request.body()));
+    }
+    return requestBuilder.build();
+  }
+
+  private HttpRequest buildHttpRequest(final Request request) {
+    return ImmutableHttpRequest.builder()
+        .url(request.url().toString())
+        .method(request.method())
+        .headers(request.headers().toMultimap())
+        .body(Optional.ofNullable(request.body()).map(RequestBody::toString).orElse(""))
+        .build();
+  }
+
+  private Call.Factory createTracedClient() {
+    if (this.tracer == null || this.tracer instanceof NoopTracer) {
+      return createTracedClientNoopTracer();
+    }
+    if (this.tracer instanceof OpenCensusTracer) {
+      return createTracedClientOpenCensus();
+    }
+    if (this.tracer instanceof OpenTelemetryTracer) {
+      return createTracedClientOpenTelemetry();
+    }
+    return createTracedClientNoopTracer();
+  }
+
+  private Call.Factory createTracedClientNoopTracer() {
+    return new Call.Factory() {
+      @NotNull
+      @Override
+      public Call newCall(@NotNull final Request request) {
+        return client.newCall(request);
+      }
+    };
+  }
+
+  private Call.Factory createTracedClientOpenTelemetry() {
+    return OkHttpTelemetry.builder(((OpenTelemetryTracer) this.tracer).getOpenTelemetry())
+        .build()
+        .newCallFactory(client);
+  }
+
+  private Call.Factory createTracedClientOpenCensus() {
+    return new Call.Factory() {
+      @NotNull
+      @Override
+      public Call newCall(@NotNull final Request request) {
+        CompletableFuture<Response> future = new CompletableFuture<>();
+        Span span =
+            OkHttpHttpClient.this
+                .tracer
+                .span(buildHttpRequest(request))
+                .addTag(TraceHelper.TraceTags.HTTP_URL, request.url().toString());
+        OkHttpClient.Builder okBuilder = client.newBuilder();
+        okBuilder
+            .networkInterceptors()
+            .add(
+                0,
+                new Interceptor() {
+                  @NotNull
+                  @Override
+                  public Response intercept(@NotNull final Chain chain) throws IOException {
+                    try {
+                      Response response = chain.proceed(chain.request());
+                      span.addTag(TraceHelper.TraceTags.HTTP_STATUS_CODE, response.code())
+                          .addTag(TraceHelper.TraceTags.HTTP_STATUS_MESSAGE, response.message())
+                          .success();
+                      future.complete(response);
+                      return response;
+                    } catch (Exception ex) {
+                      span.failure(ex);
+                      future.completeExceptionally(ex);
+                      throw ex;
+                    } finally {
+                      span.close();
+                    }
+                  }
+                });
+
+        return okBuilder.build().newCall(request);
+      }
+    };
+  }
+}