CoreTracer.builder returns NoOp if java.util.function not found

features/dd-sdk-android-trace-otel/src/test/kotlin/com/datadog/trace/core/CoreTracerTest.kt

@@ -32,7 +32,7 @@ internal class CoreTracerTest : DDCoreSpecification() {
     @Test
     fun `verify defaults on tracer`() {
         // When
-        val tracer = CoreTracer.CoreTracerBuilder(mockLogger).build()
+        val tracer = CoreTracer.builder(mockLogger).build()
 
         // Then
         assertThat(tracer.serviceName).isNotEmpty

features/dd-sdk-android-trace-otel/src/test/kotlin/com/datadog/trace/core/DDCoreSpecification.kt

@@ -15,7 +15,7 @@ import com.datadog.trace.api.sampling.PrioritySampling
 import com.datadog.trace.bootstrap.instrumentation.api.AgentTracer
 import com.datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration
 import com.datadog.trace.common.writer.ListWriter
-import com.datadog.trace.core.CoreTracer.CoreTracerBuilder
+import com.datadog.trace.core.CoreTracer.DefaultCoreTracerBuilder
 import com.datadog.trace.core.propagation.PropagationTags
 import com.datadog.trace.core.tagprocessor.TagsPostProcessorFactory
 import org.junit.jupiter.api.AfterEach
@@ -43,8 +43,8 @@ internal abstract class DDCoreSpecification : DDSpecification() {
         TagsPostProcessorFactory.reset()
     }
 
-    protected fun tracerBuilder(): CoreTracerBuilder {
-        val builder = CoreTracerBuilder(mockLogger)
+    protected fun tracerBuilder(): DefaultCoreTracerBuilder {
+        val builder = CoreTracer.builder(mockLogger)
         return builder.strictTraceWrites(useStrictTraceWrites())
     }
 

features/dd-sdk-android-trace/src/main/java/com/datadog/trace/core/CoreTracer.java

@@ -33,7 +33,6 @@
 import com.datadog.trace.api.interceptor.MutableSpan;
 import com.datadog.trace.api.interceptor.TraceInterceptor;
 import com.datadog.trace.api.internal.TraceSegment;
-import com.datadog.trace.api.metrics.SpanMetricRegistry;
 import com.datadog.trace.api.naming.SpanNaming;
 import com.datadog.trace.api.profiling.Timer;
 import com.datadog.trace.api.sampling.PrioritySampling;
@@ -82,6 +81,7 @@
 import java.lang.ref.WeakReference;
 import java.math.BigInteger;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
@@ -97,7 +97,6 @@
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
-import java.util.zip.ZipOutputStream;
 
 /**
  * Main entrypoint into the tracer implementation. In addition to implementing
@@ -261,8 +260,25 @@ public ScopeState newScopeState() {
         return scopeManager.newScopeState();
     }
 
-    public static class CoreTracerBuilder {
+    public static CoreTracerBuilder builder(InternalLogger internalLogger) {
+        try {
+            Class.forName("java.util.function.Function");
+            return new DefaultCoreTracerBuilder(internalLogger);
+        } catch (ClassNotFoundException e) {
+            internalLogger.log(
+                    InternalLogger.Level.ERROR,
+                    Arrays.asList(InternalLogger.Target.USER, InternalLogger.Target.MAINTAINER),
+                    () -> "Trying to CoreTracer implementation on Android 23 and below. " +
+                            "In order for this to properly work you will need to enable coreDesugaring " +
+                            "in your compileOptions",
+                    e,
+                    false,
+                    null);
+            return new NoOpCoreTracerBuilder();
+        }
+    }
 
+    public static class DefaultCoreTracerBuilder implements CoreTracerBuilder {
         private Config config;
         private String serviceName;
         private Writer writer = new NoOpWriter();
@@ -285,103 +301,122 @@ public static class CoreTracerBuilder {
         private InternalLogger internalLogger;
         private boolean injectBaggageAsTags;
 
-        public CoreTracerBuilder serviceName(String serviceName) {
+        @Override
+        public DefaultCoreTracerBuilder serviceName(String serviceName) {
             this.serviceName = serviceName;
             return this;
         }
 
-        public CoreTracerBuilder writer(Writer writer) {
+        @Override
+        public DefaultCoreTracerBuilder writer(Writer writer) {
             this.writer = writer;
             return this;
         }
 
-        public CoreTracerBuilder idGenerationStrategy(IdGenerationStrategy idGenerationStrategy) {
+        @Override
+        public DefaultCoreTracerBuilder idGenerationStrategy(IdGenerationStrategy idGenerationStrategy) {
             this.idGenerationStrategy = idGenerationStrategy;
             return this;
         }
 
-        public CoreTracerBuilder sampler(Sampler sampler) {
+        @Override
+        public DefaultCoreTracerBuilder sampler(Sampler sampler) {
             this.sampler = sampler;
             return this;
         }
 
-        public CoreTracerBuilder extractor(HttpCodec.Extractor extractor) {
+        @Override
+        public DefaultCoreTracerBuilder extractor(HttpCodec.Extractor extractor) {
             this.extractor = extractor;
             return this;
         }
 
-        public CoreTracerBuilder scopeManager(AgentScopeManager scopeManager) {
+        @Override
+        public DefaultCoreTracerBuilder scopeManager(AgentScopeManager scopeManager) {
             this.scopeManager = scopeManager;
             return this;
         }
 
-        public CoreTracerBuilder localRootSpanTags(Map<String, ?> localRootSpanTags) {
+        @Override
+        public DefaultCoreTracerBuilder localRootSpanTags(Map<String, ?> localRootSpanTags) {
             this.localRootSpanTags = tryMakeImmutableMap(localRootSpanTags);
             return this;
         }
 
-        public CoreTracerBuilder defaultSpanTags(Map<String, ?> defaultSpanTags) {
+        @Override
+        public DefaultCoreTracerBuilder defaultSpanTags(Map<String, ?> defaultSpanTags) {
             this.defaultSpanTags = tryMakeImmutableMap(defaultSpanTags);
             return this;
         }
 
-        public CoreTracerBuilder serviceNameMappings(Map<String, String> serviceNameMappings) {
+        @Override
+        public DefaultCoreTracerBuilder serviceNameMappings(Map<String, String> serviceNameMappings) {
             this.serviceNameMappings = tryMakeImmutableMap(serviceNameMappings);
             return this;
         }
 
-        public CoreTracerBuilder taggedHeaders(Map<String, String> taggedHeaders) {
+        @Override
+        public DefaultCoreTracerBuilder taggedHeaders(Map<String, String> taggedHeaders) {
             this.taggedHeaders = tryMakeImmutableMap(taggedHeaders);
             return this;
         }
 
-        public CoreTracerBuilder baggageMapping(Map<String, String> baggageMapping) {
+        @Override
+        public DefaultCoreTracerBuilder baggageMapping(Map<String, String> baggageMapping) {
             this.baggageMapping = tryMakeImmutableMap(baggageMapping);
             return this;
         }
 
-        public CoreTracerBuilder partialFlushMinSpans(int partialFlushMinSpans) {
+        @Override
+        public DefaultCoreTracerBuilder partialFlushMinSpans(int partialFlushMinSpans) {
             this.partialFlushMinSpans = partialFlushMinSpans;
             return this;
         }
 
-        public CoreTracerBuilder tagInterceptor(TagInterceptor tagInterceptor) {
+        @Override
+        public DefaultCoreTracerBuilder tagInterceptor(TagInterceptor tagInterceptor) {
             this.tagInterceptor = tagInterceptor;
             return this;
         }
 
-        public CoreTracerBuilder strictTraceWrites(boolean strictTraceWrites) {
+        @Override
+        public DefaultCoreTracerBuilder strictTraceWrites(boolean strictTraceWrites) {
             this.strictTraceWrites = strictTraceWrites;
             return this;
         }
 
-        public CoreTracerBuilder instrumentationGateway(InstrumentationGateway instrumentationGateway) {
+        @Override
+        public DefaultCoreTracerBuilder instrumentationGateway(InstrumentationGateway instrumentationGateway) {
             this.instrumentationGateway = instrumentationGateway;
             return this;
         }
 
-        public CoreTracerBuilder timeSource(TimeSource timeSource) {
+        @Override
+        public DefaultCoreTracerBuilder timeSource(TimeSource timeSource) {
             this.timeSource = timeSource;
             return this;
         }
 
 
-        public CoreTracerBuilder injectBaggageAsTags(boolean injectBaggageAsTags) {
+        @Override
+        public DefaultCoreTracerBuilder injectBaggageAsTags(boolean injectBaggageAsTags) {
             this.injectBaggageAsTags = injectBaggageAsTags;
             return this;
         }
 
-        public CoreTracerBuilder(InternalLogger internalLogger) {
+        public DefaultCoreTracerBuilder(InternalLogger internalLogger) {
             // Apply the default values from config.
             config(Config.get());
             this.internalLogger = internalLogger;
         }
 
-        public CoreTracerBuilder withProperties(final Properties properties) {
+        @Override
+        public DefaultCoreTracerBuilder withProperties(final Properties properties) {
             return config(Config.get(properties));
         }
 
-        public CoreTracerBuilder config(final Config config) {
+        @Override
+        public DefaultCoreTracerBuilder config(final Config config) {
             this.config = config;
             serviceName(config.getServiceName());
             // Explicitly skip setting writer to avoid allocating resources prematurely.
@@ -399,7 +434,8 @@ public CoreTracerBuilder config(final Config config) {
             return this;
         }
 
-        public CoreTracer build() {
+        @Override
+        public AgentTracer.TracerAPI build() {
             return new CoreTracer(
                     config,
                     serviceName,

features/dd-sdk-android-trace/src/main/java/com/datadog/trace/core/CoreTracerBuilder.java

@@ -0,0 +1,63 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.trace.core;
+
+import com.datadog.trace.api.Config;
+import com.datadog.trace.api.IdGenerationStrategy;
+import com.datadog.trace.api.gateway.InstrumentationGateway;
+import com.datadog.trace.api.time.TimeSource;
+import com.datadog.trace.bootstrap.instrumentation.api.AgentScopeManager;
+import com.datadog.trace.bootstrap.instrumentation.api.AgentTracer;
+import com.datadog.trace.common.sampling.Sampler;
+import com.datadog.trace.common.writer.Writer;
+import com.datadog.trace.core.propagation.HttpCodec;
+import com.datadog.trace.core.taginterceptor.TagInterceptor;
+
+import java.util.Map;
+import java.util.Properties;
+
+public interface CoreTracerBuilder {
+    CoreTracerBuilder serviceName(String serviceName);
+
+   CoreTracerBuilder writer(Writer writer);
+
+   CoreTracerBuilder idGenerationStrategy(IdGenerationStrategy idGenerationStrategy);
+
+   CoreTracerBuilder sampler(Sampler sampler);
+
+   CoreTracerBuilder extractor(HttpCodec.Extractor extractor);
+
+   CoreTracerBuilder scopeManager(AgentScopeManager scopeManager);
+
+   CoreTracerBuilder localRootSpanTags(Map<String, ?> localRootSpanTags);
+
+   CoreTracerBuilder defaultSpanTags(Map<String, ?> defaultSpanTags);
+
+   CoreTracerBuilder serviceNameMappings(Map<String, String> serviceNameMappings);
+
+   CoreTracerBuilder taggedHeaders(Map<String, String> taggedHeaders);
+
+   CoreTracerBuilder baggageMapping(Map<String, String> baggageMapping);
+
+   CoreTracerBuilder partialFlushMinSpans(int partialFlushMinSpans);
+
+   CoreTracerBuilder tagInterceptor(TagInterceptor tagInterceptor);
+
+   CoreTracerBuilder strictTraceWrites(boolean strictTraceWrites);
+
+   CoreTracerBuilder instrumentationGateway(InstrumentationGateway instrumentationGateway);
+
+   CoreTracerBuilder timeSource(TimeSource timeSource);
+
+   CoreTracerBuilder injectBaggageAsTags(boolean injectBaggageAsTags);
+
+   CoreTracerBuilder withProperties(Properties properties);
+
+   CoreTracerBuilder config(Config config);
+
+    AgentTracer.TracerAPI build();
+}