diff --git a/.gitignore b/.gitignore
index aa724b7..f8536d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,8 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/androidTestResultsUserPreferences.xml
+/.idea/deploymentTargetSelector.xml
 .DS_Store
 /build
 /captures
diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
deleted file mode 100644
index b268ef3..0000000
--- a/.idea/deploymentTargetSelector.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="deploymentTargetSelector">
-    <selectionStates>
-      <SelectionState runConfigName="app">
-        <option name="selectionMode" value="DROPDOWN" />
-      </SelectionState>
-    </selectionStates>
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 8a8ebfa..b5210f3 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 0ad17cb..8978d23 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index e3f8a07..d1a1429 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,6 +1,5 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    alias(libs.plugins.android.application) apply false
     alias(libs.plugins.jetbrains.kotlin.android) apply false
     alias(libs.plugins.android.library) apply false
-}
\ No newline at end of file
+}
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index ec4a8c6..74a36e3 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -10,10 +10,14 @@ android {
     defaultConfig {
         minSdk = 21
 
+        buildConfigField("String","HONEYCOMB_DISTRO_VERSION","\"0.0.1-alpha\"")
+
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles("consumer-rules.pro")
     }
-
+    buildFeatures {
+        buildConfig = true
+    }
     buildTypes {
         release {
             isMinifyEnabled = false
@@ -24,6 +28,7 @@ android {
         }
     }
     compileOptions {
+        isCoreLibraryDesugaringEnabled = true
         sourceCompatibility = JavaVersion.VERSION_1_8
         targetCompatibility = JavaVersion.VERSION_1_8
     }
@@ -33,11 +38,17 @@ android {
 }
 
 dependencies {
+    // This is required by opentelemetry-android.
+    coreLibraryDesugaring(libs.desugar.jdk.libs)
 
     implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.appcompat)
-    implementation(libs.material)
+    implementation(libs.opentelemetry.android.agent)
+    implementation(libs.opentelemetry.api)
+    implementation(libs.opentelemetry.sdk)
+    implementation(libs.opentelemetry.exporter.otlp)
+
     testImplementation(libs.junit)
+
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
-}
\ No newline at end of file
+}
diff --git a/core/src/androidTest/java/io/honeycomb/opentelemetry/android/ExampleInstrumentedTest.kt b/core/src/androidTest/java/io/honeycomb/opentelemetry/android/ExampleInstrumentedTest.kt
deleted file mode 100644
index 3dab2a4..0000000
--- a/core/src/androidTest/java/io/honeycomb/opentelemetry/android/ExampleInstrumentedTest.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package io.honeycomb.opentelemetry.android
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("io.honeycomb.opentelemetry.android.test", appContext.packageName)
-    }
-}
\ No newline at end of file
diff --git a/core/src/androidTest/java/io/honeycomb/opentelemetry/android/HoneycombOptionsInstrumentedTest.kt b/core/src/androidTest/java/io/honeycomb/opentelemetry/android/HoneycombOptionsInstrumentedTest.kt
new file mode 100644
index 0000000..8031ef7
--- /dev/null
+++ b/core/src/androidTest/java/io/honeycomb/opentelemetry/android/HoneycombOptionsInstrumentedTest.kt
@@ -0,0 +1,81 @@
+package io.honeycomb.opentelemetry.android
+
+import android.os.Build
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ */
+@RunWith(AndroidJUnit4::class)
+class HoneycombOptionsInstrumentedTest {
+    @Test
+    fun builder_usesContext() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("io.honeycomb.opentelemetry.android.test", context.packageName)
+
+        val options = HoneycombOptions.builder(context).build()
+        assertEquals("key", options.tracesApiKey)
+    }
+
+    @Test
+    fun runtimeVersion_isAutomaticallySet() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val options = HoneycombOptions.builder(context).build()
+        assertEquals(
+            mapOf(
+                "service.name" to "unknown_service",
+                "honeycomb.distro.version" to "0.0.1-alpha",
+                "honeycomb.distro.runtime_version" to Build.VERSION.RELEASE,
+            ), options.resourceAttributes
+        )
+    }
+
+    @Test
+    fun source_getString() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertEquals("some string", source.getString("STRING"))
+    }
+
+    @Test
+    fun source_getNullForEmptyString() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertNull(source.getString("EMPTY_STRING"))
+    }
+
+    @Test
+    fun source_getNullForBlankString() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertNull(source.getString("BLANK_STRING"))
+    }
+
+    @Test
+    fun source_getInt() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertEquals(5000, source.getInt("NUMBER"))
+    }
+
+    @Test
+    fun source_getDuration() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertEquals(5.seconds, source.getDuration("NUMBER"))
+    }
+
+    @Test
+    fun source_getBoolean() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val source = HoneycombOptionsResourceSource(context)
+        assertEquals(true, source.getBoolean("BOOL"))
+    }
+}
diff --git a/core/src/androidTest/res/values/test_values.xml b/core/src/androidTest/res/values/test_values.xml
new file mode 100644
index 0000000..38326ac
--- /dev/null
+++ b/core/src/androidTest/res/values/test_values.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="HONEYCOMB_API_KEY">key</string>
+    <string name="STRING">some string</string>
+    <string name="EMPTY_STRING"></string>
+    <string name="BLANK_STRING">     </string>
+    <integer name="NUMBER">5000</integer>
+    <bool name="BOOL">true</bool>
+</resources>
diff --git a/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptions.kt b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptions.kt
new file mode 100644
index 0000000..1cc3741
--- /dev/null
+++ b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptions.kt
@@ -0,0 +1,528 @@
+package io.honeycomb.opentelemetry.android
+
+import android.content.Context
+import android.os.Build
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+private const val HONEYCOMB_API_KEY_KEY = "HONEYCOMB_API_KEY"
+private const val HONEYCOMB_TRACES_APIKEY_KEY = "HONEYCOMB_TRACES_APIKEY"
+private const val HONEYCOMB_METRICS_APIKEY_KEY = "HONEYCOMB_METRICS_APIKEY"
+private const val HONEYCOMB_LOGS_APIKEY_KEY = "HONEYCOMB_LOGS_APIKEY"
+
+private const val HONEYCOMB_DATASET_KEY = "HONEYCOMB_DATASET"
+private const val HONEYCOMB_METRICS_DATASET_KEY = "HONEYCOMB_METRICS_DATASET"
+
+private const val HONEYCOMB_API_ENDPOINT_KEY = "HONEYCOMB_API_ENDPOINT"
+private const val HONEYCOMB_API_ENDPOINT_DEFAULT = "https://api.honeycomb.io:443"
+private const val HONEYCOMB_TRACES_ENDPOINT_KEY = "HONEYCOMB_TRACES_ENDPOINT"
+private const val HONEYCOMB_METRICS_ENDPOINT_KEY = "HONEYCOMB_METRICS_ENDPOINT"
+private const val HONEYCOMB_LOGS_ENDPOINT_KEY = "HONEYCOMB_LOGS_ENDPOINT"
+
+private const val SAMPLE_RATE_KEY = "SAMPLE_RATE"
+private const val DEBUG_KEY = "DEBUG"
+
+private const val OTEL_SERVICE_NAME_KEY = "OTEL_SERVICE_NAME"
+private const val OTEL_SERVICE_NAME_DEFAULT = "unknown_service"
+private const val OTEL_RESOURCE_ATTRIBUTES_KEY = "OTEL_RESOURCE_ATTRIBUTES"
+
+private const val OTEL_TRACES_SAMPLER_KEY = "OTEL_TRACES_SAMPLER"
+private const val OTEL_TRACES_SAMPLER_DEFAULT = "parentbased_always_on"
+private const val OTEL_TRACES_SAMPLER_ARG_KEY = "OTEL_TRACES_SAMPLER_ARG"
+
+private const val OTEL_PROPAGATORS_KEY = "OTEL_PROPAGATORS"
+private const val OTEL_PROPAGATORS_DEFAULT = "tracecontext,baggage"
+
+private const val OTEL_TRACES_EXPORTER_KEY = "OTEL_TRACES_EXPORTER"
+private const val OTEL_METRICS_EXPORTER_KEY = "OTEL_METRICS_EXPORTER"
+private const val OTEL_LOGS_EXPORTER_KEY = "OTEL_METRICS_EXPORTER"
+
+private const val OTEL_EXPORTER_OTLP_HEADERS_KEY = "OTEL_EXPORTER_OTLP_HEADERS"
+private const val OTEL_EXPORTER_OTLP_TRACES_HEADERS_KEY = "OTEL_EXPORTER_OTLP_TRACES_HEADERS"
+private const val OTEL_EXPORTER_OTLP_METRICS_HEADERS_KEY = "OTEL_EXPORTER_OTLP_METRICS_HEADERS"
+private const val OTEL_EXPORTER_OTLP_LOGS_HEADERS_KEY = "OTEL_EXPORTER_OTLP_LOGS_HEADERS"
+
+private const val OTEL_EXPORTER_OTLP_TIMEOUT_KEY = "OTEL_EXPORTER_OTLP_TIMEOUT"
+private const val OTEL_EXPORTER_OTLP_TRACES_TIMEOUT_KEY = "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT"
+private const val OTEL_EXPORTER_OTLP_METRICS_TIMEOUT_KEY = "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT"
+private const val OTEL_EXPORTER_OTLP_LOGS_TIMEOUT_KEY = "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT"
+
+private const val OTEL_EXPORTER_OTLP_PROTOCOL_KEY = "OTEL_EXPORTER_OTLP_PROTOCOL"
+private const val OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_KEY = "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL"
+private const val OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_KEY = "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL"
+private const val OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_KEY = "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL"
+
+/** The protocol for OTLP to use when talking to its backend. */
+enum class OtlpProtocol {
+    GRPC,
+    HTTP_PROTOBUF,
+    HTTP_JSON;
+
+    companion object {
+        internal fun parse(s: String): OtlpProtocol? {
+            return when (s) {
+                "" -> null
+                "grpc" -> GRPC
+                "http/protobuf" -> HTTP_PROTOBUF
+                "http/json" -> HTTP_JSON
+                else -> throw IllegalArgumentException("invalid protocol $s")
+            }
+        }
+    }
+}
+
+private val CLASSIC_KEY_REGEX = Regex("[a-f0-9]*")
+private val INGEST_CLASSIC_KEY_REGEX = Regex("hc[a-z]ic_[a-z0-9]*")
+
+/**
+ * Returns whether the passed in API key is classic or not.
+ */
+private fun isClassicKey(key: String): Boolean {
+    return when (key.length) {
+        0 -> false
+        32 -> CLASSIC_KEY_REGEX.matches(key)
+        64 -> INGEST_CLASSIC_KEY_REGEX.matches(key)
+        else -> false
+    }
+}
+
+/**
+ * Gets the endpoint to use for a particular signal.
+ *
+ * The logic is this:
+ * 1. If HONEYCOMB_signal_ENDPOINT is set, return it.
+ * 2. Determine the base url:
+ *    a. If HONEYCOMB_API_ENDPOINT is set, that's the base url.
+ *    b. Else, use the default as the base url.
+ * 3. If the protocol is GRPC, return the base url.
+ * 4. If the protocol is HTTP, return the base url with a suffix based on the signal.
+ *
+ * Note that even though OpenTelemetry defines its own defaults for endpoints, they will never be
+ * used, as the standard Honeycomb-specific logic falls back to its own default.
+ */
+private fun getHoneycombEndpoint(
+    endpoint: String?,
+    fallback: String,
+    protocol: OtlpProtocol,
+    suffix: String
+): String {
+    if (endpoint != null) {
+        return endpoint
+    }
+    if (protocol == OtlpProtocol.GRPC) {
+        return fallback
+    }
+    return if (fallback.endsWith("/")) {
+        "$fallback$suffix"
+    } else {
+        "$fallback/$suffix"
+    }
+}
+
+/**
+ * Gets the headers to use for a particular exporter.
+ */
+private fun getHeaders(
+    apiKey: String,
+    dataset: String?,
+    generalHeaders: Map<String, String>,
+    signalHeaders: Map<String, String>,
+): Map<String, String> {
+
+    val otlpVersion = io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION
+    val baseHeaders = mapOf("x-otlp-version" to otlpVersion)
+    val signalBaseHeaders = mutableMapOf("x-honeycomb-team" to apiKey)
+    dataset?.let { signalBaseHeaders["x-honeycomb-dataset"] = it }
+
+    return baseHeaders + generalHeaders + signalBaseHeaders + signalHeaders
+}
+
+/** An error when configuring OpenTelemetry for Honeycomb. */
+class HoneycombException(message: String) : Exception(message)
+
+/**
+ * The set of options for how to configure Honeycomb.
+ *
+ * These keys and defaults are defined at:
+ * https://github.com/honeycombio/specs/blob/main/specs/otel-sdk-distro.md
+ * https://opentelemetry.io/docs/languages/sdk-configuration/general/
+ * https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+ */
+data class HoneycombOptions(
+    val tracesApiKey: String,
+    val metricsApiKey: String,
+    val logsApiKey: String,
+    val dataset: String?,
+    val metricsDataset: String?,
+    val tracesEndpoint: String,
+    val metricsEndpoint: String,
+    val logsEndpoint: String,
+    val sampleRate: Int,
+    val debug: Boolean,
+
+    val serviceName: String,
+    val resourceAttributes: Map<String, String>,
+    val tracesSampler: String,
+    val tracesSamplerArg: String?,
+    val propagators: String,
+
+    val tracesHeaders: Map<String, String>,
+    val metricsHeaders: Map<String, String>,
+    val logsHeaders: Map<String, String>,
+
+    val tracesTimeout: Duration,
+    val metricsTimeout: Duration,
+    val logsTimeout: Duration,
+
+    val tracesProtocol: OtlpProtocol,
+    val metricsProtocol: OtlpProtocol,
+    val logsProtocol: OtlpProtocol,
+) {
+    class Builder private constructor() {
+        private var apiKey: String? = null
+        private var tracesApiKey: String? = null
+        private var metricsApiKey: String? = null
+        private var logsApiKey: String? = null
+
+        private var dataset: String? = null
+        private var metricsDataset: String? = null
+
+        private var apiEndpoint: String = HONEYCOMB_API_ENDPOINT_DEFAULT
+        private var tracesEndpoint: String? = null
+        private var metricsEndpoint: String? = null
+        private var logsEndpoint: String? = null
+
+        private var sampleRate: Int = 1
+        private var debug: Boolean = false
+
+        private var serviceName: String? = null
+        private var resourceAttributes: Map<String, String> = mapOf()
+        private var tracesSampler: String = OTEL_TRACES_SAMPLER_DEFAULT
+        private var tracesSamplerArg: String? = null
+        private var propagators: String = OTEL_PROPAGATORS_DEFAULT
+
+        private var headers: Map<String, String> = mapOf()
+        private var tracesHeaders: Map<String, String> = mapOf()
+        private var metricsHeaders: Map<String, String> = mapOf()
+        private var logsHeaders: Map<String, String> = mapOf()
+
+        private var timeout: Duration = 10.seconds
+        private var tracesTimeout: Duration? = null
+        private var metricsTimeout: Duration? = null
+        private var logsTimeout: Duration? = null
+
+        private var protocol: OtlpProtocol = OtlpProtocol.HTTP_PROTOBUF
+        private var tracesProtocol: OtlpProtocol? = null
+        private var metricsProtocol: OtlpProtocol? = null
+        private var logsProtocol: OtlpProtocol? = null
+
+        constructor(context: Context) : this(HoneycombOptionsResourceSource(context)) {}
+
+        internal constructor(source: HoneycombOptionsSource) : this() {
+            configureFromSource(source)
+        }
+
+        private fun verifyExporter(source: HoneycombOptionsSource, key: String) {
+            val exporter = source.getString(key)?.lowercase() ?: "otlp"
+            if (exporter != "otlp") {
+                throw HoneycombException("unsupported exporter $exporter for $key")
+            }
+        }
+
+        private fun configureFromSource(source: HoneycombOptionsSource) {
+            // Make sure the exporters aren't set to anything other than OTLP.
+            verifyExporter(source, OTEL_TRACES_EXPORTER_KEY)
+            verifyExporter(source, OTEL_METRICS_EXPORTER_KEY)
+            verifyExporter(source, OTEL_LOGS_EXPORTER_KEY)
+
+            apiKey = source.getString(HONEYCOMB_API_KEY_KEY)
+            tracesApiKey = source.getString(HONEYCOMB_TRACES_APIKEY_KEY)
+            metricsApiKey = source.getString(HONEYCOMB_METRICS_APIKEY_KEY)
+            logsApiKey = source.getString(HONEYCOMB_LOGS_APIKEY_KEY)
+            dataset = source.getString(HONEYCOMB_DATASET_KEY)
+            metricsDataset = source.getString(HONEYCOMB_METRICS_DATASET_KEY)
+            apiEndpoint = source.getString(HONEYCOMB_API_ENDPOINT_KEY) ?: apiEndpoint
+            tracesEndpoint = source.getString(HONEYCOMB_TRACES_ENDPOINT_KEY)
+            metricsEndpoint = source.getString(HONEYCOMB_METRICS_ENDPOINT_KEY)
+            logsEndpoint = source.getString(HONEYCOMB_LOGS_ENDPOINT_KEY)
+            sampleRate = source.getInt(SAMPLE_RATE_KEY) ?: sampleRate
+            debug = source.getBoolean(DEBUG_KEY) ?: debug
+            serviceName = source.getString(OTEL_SERVICE_NAME_KEY) ?: serviceName
+            resourceAttributes = source.getKeyValueList(OTEL_RESOURCE_ATTRIBUTES_KEY)
+            tracesSampler = source.getString(OTEL_TRACES_SAMPLER_KEY) ?: tracesSampler
+            tracesSamplerArg = source.getString(OTEL_TRACES_SAMPLER_ARG_KEY)
+            propagators = source.getString(OTEL_PROPAGATORS_KEY) ?: propagators
+            headers = source.getKeyValueList(OTEL_EXPORTER_OTLP_HEADERS_KEY)
+            tracesHeaders = source.getKeyValueList(OTEL_EXPORTER_OTLP_TRACES_HEADERS_KEY)
+            metricsHeaders = source.getKeyValueList(OTEL_EXPORTER_OTLP_METRICS_HEADERS_KEY)
+            logsHeaders = source.getKeyValueList(OTEL_EXPORTER_OTLP_LOGS_HEADERS_KEY)
+            timeout = source.getDuration(OTEL_EXPORTER_OTLP_TIMEOUT_KEY) ?: timeout
+            tracesTimeout = source.getDuration(OTEL_EXPORTER_OTLP_TRACES_TIMEOUT_KEY)
+            metricsTimeout = source.getDuration(OTEL_EXPORTER_OTLP_METRICS_TIMEOUT_KEY)
+            logsTimeout = source.getDuration(OTEL_EXPORTER_OTLP_LOGS_TIMEOUT_KEY)
+            protocol = source.getOtlpProtocol(OTEL_EXPORTER_OTLP_PROTOCOL_KEY) ?: protocol
+            tracesProtocol = source.getOtlpProtocol(OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_KEY)
+            metricsProtocol = source.getOtlpProtocol(OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_KEY)
+            logsProtocol = source.getOtlpProtocol(OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_KEY)
+        }
+
+        fun setApiKey(apiKey: String): Builder {
+            this.apiKey = apiKey
+            return this
+        }
+
+        fun setTracesApiKey(apiKey: String): Builder {
+            tracesApiKey = apiKey
+            return this
+        }
+
+        fun setMetricsApiKey(apiKey: String): Builder {
+            metricsApiKey = apiKey
+            return this
+        }
+
+        fun setLogsApiKey(apiKey: String): Builder {
+            logsApiKey = apiKey
+            return this
+        }
+
+        fun setDataset(dataset: String): Builder {
+            this.dataset = dataset
+            return this
+        }
+
+        fun setMetricsDataset(dataset: String): Builder {
+            metricsDataset = dataset
+            return this
+        }
+
+        fun setApiEndpoint(endpoint: String): Builder {
+            apiEndpoint = endpoint
+            return this
+        }
+
+        fun setTracesApiEndpoint(endpoint: String): Builder {
+            tracesEndpoint = endpoint
+            return this
+        }
+
+        fun setMetricsApiEndpoint(endpoint: String): Builder {
+            metricsEndpoint = endpoint
+            return this
+        }
+
+        fun setLogsApiEndpoint(endpoint: String): Builder {
+            logsEndpoint = endpoint
+            return this
+        }
+
+        fun setSampleRate(sampleRate: Int): Builder {
+            this.sampleRate = sampleRate
+            return this
+        }
+
+        fun setDebug(debug: Boolean): Builder {
+            this.debug = debug
+            return this
+        }
+
+        fun setServiceName(serviceName: String): Builder {
+            this.serviceName = serviceName
+            return this
+        }
+
+        fun setResourceAttributes(resources: Map<String, String>): Builder {
+            resourceAttributes = resources
+            return this
+        }
+
+        fun setTracesSampler(sampler: String): Builder {
+            tracesSampler = sampler
+            return this
+        }
+
+        fun setTracesSamplerArg(arg: String?): Builder {
+            tracesSamplerArg = arg
+            return this
+        }
+
+        fun setPropagators(propagators: String): Builder {
+            this.propagators = propagators
+            return this
+        }
+
+        fun setHeaders(headers: Map<String, String>): Builder {
+            this.headers = headers
+            return this
+        }
+
+        fun setTracesHeaders(headers: Map<String, String>): Builder {
+            tracesHeaders = headers
+            return this
+        }
+
+        fun setMetricsHeaders(headers: Map<String, String>): Builder {
+            metricsHeaders = headers
+            return this
+        }
+
+        fun setLogsHeaders(headers: Map<String, String>): Builder {
+            logsHeaders = headers
+            return this
+        }
+
+        fun setTimeout(timeout: Duration): Builder {
+            this.timeout = timeout
+            return this
+        }
+
+        fun setTracesTimeout(timeout: Duration): Builder {
+            tracesTimeout = timeout
+            return this
+        }
+
+        fun setMetricsTimeout(timeout: Duration): Builder {
+            metricsTimeout = timeout
+            return this
+        }
+
+        fun setLogsTimeout(timeout: Duration): Builder {
+            logsTimeout = timeout
+            return this
+        }
+
+        fun setProtocol(protocol: OtlpProtocol): Builder {
+            this.protocol = protocol
+            return this
+        }
+
+        fun setTracesProtocol(protocol: OtlpProtocol): Builder {
+            tracesProtocol = protocol
+            return this
+        }
+
+        fun setMetricsProtocol(protocol: OtlpProtocol): Builder {
+            metricsProtocol = protocol
+            return this
+        }
+
+        fun setLogsProtocol(protocol: OtlpProtocol): Builder {
+            logsProtocol = protocol
+            return this
+        }
+
+        fun build(): HoneycombOptions {
+            // If any API key isn't set, consider it a fatal error.
+            val defaultApiKey: () -> String = { ->
+                if (apiKey == null) {
+                    throw HoneycombException("missing API key: call setApiKey()")
+                }
+                apiKey as String
+            }
+
+            // Collect the non-exporter-specific values.
+            val resourceAttributes = resourceAttributes.toMutableMap()
+            // Any explicit service name overrides the one in the resource attributes.
+            val serviceName: String =
+                this.serviceName
+                    ?: resourceAttributes["service.name"]
+                    ?: OTEL_SERVICE_NAME_DEFAULT
+
+            /*
+             * Add automatic entries to resource attributes. According to the Honeycomb spec,
+             * resource attributes should never be overwritten by automatic values. So, if there are
+             * two different service names set, this will use the resource attributes version.
+             */
+            // Make sure the service name is in the resource attributes.
+            resourceAttributes.putIfAbsent("service.name", serviceName)
+            // The SDK version is generated from build.gradle.kts.
+            resourceAttributes.putIfAbsent(
+                "honeycomb.distro.version",
+                BuildConfig.HONEYCOMB_DISTRO_VERSION
+            )
+            // Use the display version of Android. This is "unknown" when running tests in the JVM.
+            resourceAttributes.putIfAbsent(
+                "honeycomb.distro.runtime_version",
+                Build.VERSION.RELEASE ?: "unknown"
+            )
+
+            val tracesApiKey = this.tracesApiKey ?: defaultApiKey()
+            val metricsApiKey = this.metricsApiKey ?: defaultApiKey()
+            val logsApiKey = this.logsApiKey ?: defaultApiKey()
+
+            val tracesHeaders =
+                getHeaders(
+                    tracesApiKey,
+                    if (isClassicKey(tracesApiKey)) dataset else null,
+                    headers,
+                    this.tracesHeaders,
+                )
+            val metricsHeaders =
+                getHeaders(
+                    metricsApiKey,
+                    metricsDataset,
+                    headers,
+                    this.metricsHeaders,
+                )
+            val logsHeaders =
+                getHeaders(
+                    logsApiKey,
+                    if (isClassicKey(tracesApiKey)) dataset else null,
+                    headers,
+                    this.logsHeaders,
+                )
+
+            val tracesEndpoint = getHoneycombEndpoint(
+                this.tracesEndpoint,
+                apiEndpoint,
+                tracesProtocol ?: protocol,
+                "v1/traces"
+            )
+            val metricsEndpoint = getHoneycombEndpoint(
+                this.metricsEndpoint,
+                apiEndpoint,
+                metricsProtocol ?: protocol,
+                "v1/metrics"
+            )
+            val logsEndpoint = getHoneycombEndpoint(
+                this.logsEndpoint,
+                apiEndpoint,
+                logsProtocol ?: protocol,
+                "v1/logs"
+            )
+
+            return HoneycombOptions(
+                tracesApiKey,
+                metricsApiKey,
+                logsApiKey,
+                dataset,
+                metricsDataset,
+                tracesEndpoint,
+                metricsEndpoint,
+                logsEndpoint,
+                sampleRate,
+                debug,
+                serviceName,
+                resourceAttributes,
+                tracesSampler,
+                tracesSamplerArg,
+                propagators,
+                tracesHeaders,
+                metricsHeaders,
+                logsHeaders,
+                tracesTimeout ?: timeout,
+                metricsTimeout ?: timeout,
+                logsTimeout ?: timeout,
+                tracesProtocol ?: protocol,
+                metricsProtocol ?: protocol,
+                logsProtocol ?: protocol,
+            )
+        }
+    }
+
+    companion object {
+        fun builder(context: Context): HoneycombOptions.Builder {
+            return Builder(context)
+        }
+    }
+}
diff --git a/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsResourceSource.kt b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsResourceSource.kt
new file mode 100644
index 0000000..8dde43d
--- /dev/null
+++ b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsResourceSource.kt
@@ -0,0 +1,40 @@
+package io.honeycomb.opentelemetry.android
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Resources
+
+/**
+ * A HoneycombOptionsSource that reads from values resources.
+ */
+// DiscouragedApi is suppressed, because while it's not recommended to get an identifier by its
+// string, it's the only way for a library to look up an optional value resource.
+@SuppressLint("DiscouragedApi")
+internal class HoneycombOptionsResourceSource(context: Context) : HoneycombOptionsSource {
+    private val resources: Resources = context.resources
+    private val packageName: String = context.packageName
+
+    override fun getString(key: String): String? {
+        val id = resources.getIdentifier(key, "string", packageName)
+        if (id == 0) {
+            return null
+        }
+        return resources.getString(id).trim().ifEmpty { null }
+    }
+
+    override fun getInt(key: String): Int? {
+        val id = resources.getIdentifier(key, "integer", packageName)
+        if (id == 0) {
+            return null
+        }
+        return resources.getInteger(id)
+    }
+
+    override fun getBoolean(key: String): Boolean? {
+        val id = resources.getIdentifier(key, "bool", packageName)
+        if (id == 0) {
+            return null
+        }
+        return resources.getBoolean(id)
+    }
+}
diff --git a/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsSource.kt b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsSource.kt
new file mode 100644
index 0000000..8f534da
--- /dev/null
+++ b/core/src/main/java/io/honeycomb/opentelemetry/android/HoneycombOptionsSource.kt
@@ -0,0 +1,62 @@
+package io.honeycomb.opentelemetry.android
+
+import java.net.URLDecoder
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * A dictionary with keys and values for configuring Honeycomb.
+ * Provides getters that enforce type safety.
+ */
+internal interface HoneycombOptionsSource {
+    /** Gets a String value. */
+    fun getString(key: String): String?
+
+    /** Gets an Int value. */
+    fun getInt(key: String): Int?
+
+    /** Gets a Boolean value. */
+    fun getBoolean(key: String): Boolean?
+
+    /** Gets a Duration value, which is represented as an integer (in milliseconds). */
+    fun getDuration(key: String): Duration? {
+        return getInt(key)?.milliseconds
+    }
+
+    /** Gets an OTLP protocol, */
+    fun getOtlpProtocol(key: String): OtlpProtocol? {
+        return getString(key)?.let { OtlpProtocol.parse(it) }
+    }
+
+    /** Gets and parses a comma-delimited list of key-value pairs. */
+    fun getKeyValueList(key: String): Map<String, String> {
+        return getString(key)?.let { parseKeyValueList(it) }.orEmpty()
+    }
+
+    /**
+     * Parses a list of key-value pairs, as used in specifying resources and headers.
+     * Headers are comma-separated pairs with equals, such as:
+     *     key1=value1,key2=value2
+     * See the format specified here:
+     *     https://opentelemetry.io/docs/specs/otel/resource/sdk/#specifying-resource-information-via-an-environment-variable
+     */
+    @Suppress("DEPRECATION")
+    private fun parseKeyValueList(keyValueString: String): Map<String, String> {
+        val result = HashMap<String, String>()
+        val parts = keyValueString.split(",").map { it.trim() }
+        parts.filter { it.isNotEmpty() }.map {
+            val keyAndValue = it.split("=").map { it.trim() }
+            if (keyAndValue.size != 2) {
+                throw HoneycombException("invalid key-value pair: $it")
+            }
+            // We use the deprecated version of URLDecoder.decode, because:
+            // 1. The current version requires Android minSdk API level 33 or higher.
+            // 2. Uri.decode would replace invalid encodings with \uFFFD instead of throwing.
+            // 3. Uri.decode is Android-specific, and won't work in unit tests.
+            val key = URLDecoder.decode(keyAndValue[0])
+            val value = URLDecoder.decode(keyAndValue[1])
+            result[key] = value
+        }
+        return result
+    }
+}
diff --git a/core/src/test/java/io/honeycomb/opentelemetry/android/ExampleUnitTest.kt b/core/src/test/java/io/honeycomb/opentelemetry/android/ExampleUnitTest.kt
deleted file mode 100644
index f19bdbc..0000000
--- a/core/src/test/java/io/honeycomb/opentelemetry/android/ExampleUnitTest.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package io.honeycomb.opentelemetry.android
-
-import org.junit.Test
-
-import org.junit.Assert.*
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
\ No newline at end of file
diff --git a/core/src/test/java/io/honeycomb/opentelemetry/android/HoneycombOptionsUnitTest.kt b/core/src/test/java/io/honeycomb/opentelemetry/android/HoneycombOptionsUnitTest.kt
new file mode 100644
index 0000000..8743ae7
--- /dev/null
+++ b/core/src/test/java/io/honeycomb/opentelemetry/android/HoneycombOptionsUnitTest.kt
@@ -0,0 +1,648 @@
+package io.honeycomb.opentelemetry.android
+
+import org.junit.Test
+import org.junit.Assert.*
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * An implementation of OpenTelemetryConfigSource that reads from a HashMap, so that unit tests can
+ * run in the JVM, rather than requiring Android-specific classes.
+ */
+class HoneycombOptionsMapSource(private val data: Map<String, Any?>) : HoneycombOptionsSource {
+    override fun getString(key: String): String? {
+        val value = data[key] ?: return null
+        if (value !is String) {
+            throw IllegalArgumentException("$value is not a String")
+        }
+        if (value.isBlank()) {
+            return null
+        }
+        return value.trim()
+    }
+
+    override fun getInt(key: String): Int? {
+        val value = data[key] ?: return null
+        if (value !is Int) {
+            throw IllegalArgumentException("$value is not an Int")
+        }
+        return value
+    }
+
+    override fun getBoolean(key: String): Boolean? {
+        val value = data[key] ?: return null
+        if (value !is Boolean) {
+            throw IllegalArgumentException("$value is not a Boolean")
+        }
+        return value
+    }
+}
+
+/**
+ * Tests for loading a config from a source of String -> Any?.
+ */
+class HoneycombOptionsUnitTest {
+    @Test
+    fun options_requireHoneycombKey() {
+        val data = hashMapOf<String, Any?>()
+        assertThrows(HoneycombException::class.java) {
+            HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+        }
+    }
+
+    @Test
+    fun options_hasCorrectDefaults() {
+        val data = hashMapOf<String, Any?>("HONEYCOMB_API_KEY" to "key")
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+
+        assertEquals("unknown_service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "unknown_service",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ),
+            options.resourceAttributes,
+        )
+
+        assertEquals("parentbased_always_on", options.tracesSampler)
+        assertNull(options.tracesSamplerArg)
+        assertEquals("tracecontext,baggage", options.propagators)
+
+        assertEquals("https://api.honeycomb.io:443/v1/traces", options.tracesEndpoint)
+        assertEquals("https://api.honeycomb.io:443/v1/metrics", options.metricsEndpoint)
+        assertEquals("https://api.honeycomb.io:443/v1/logs", options.logsEndpoint)
+
+        val expectedHeaders = mapOf(
+            "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            "x-honeycomb-team" to "key",
+        )
+        assertEquals(expectedHeaders, options.tracesHeaders)
+        assertEquals(expectedHeaders, options.metricsHeaders)
+        assertEquals(expectedHeaders, options.logsHeaders)
+
+        assertEquals(10.seconds, options.tracesTimeout)
+        assertEquals(10.seconds, options.metricsTimeout)
+        assertEquals(10.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.logsProtocol)
+
+        assertEquals(1, options.sampleRate)
+        assertFalse(options.debug)
+    }
+
+    @Test
+    fun options_handlesEmptyStrings() {
+        val data = hashMapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "OTEL_SERVICE_NAME" to "",
+            "OTEL_RESOURCE_ATTRIBUTES" to "",
+            "OTEL_TRACES_SAMPLER" to "",
+            "OTEL_TRACES_SAMPLER_ARG" to "",
+            "OTEL_PROPAGATORS" to "",
+            "OTEL_EXPORTER_OTLP_HEADERS" to "",
+            "OTEL_EXPORTER_OTLP_TIMEOUT" to null,
+            "OTEL_EXPORTER_OTLP_PROTOCOL" to "",
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+
+        assertEquals("unknown_service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "unknown_service",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ),
+            options.resourceAttributes
+        )
+
+        assertEquals("parentbased_always_on", options.tracesSampler)
+        assertNull(options.tracesSamplerArg)
+        assertEquals("tracecontext,baggage", options.propagators)
+
+        assertEquals("https://api.honeycomb.io:443/v1/traces", options.tracesEndpoint)
+        assertEquals("https://api.honeycomb.io:443/v1/metrics", options.metricsEndpoint)
+        assertEquals("https://api.honeycomb.io:443/v1/logs", options.logsEndpoint)
+
+        val expectedHeaders = mapOf<String, String>(
+            "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            "x-honeycomb-team" to "key",
+        )
+        assertEquals(expectedHeaders, options.tracesHeaders)
+        assertEquals(expectedHeaders, options.metricsHeaders)
+        assertEquals(expectedHeaders, options.logsHeaders)
+
+        assertEquals(10.seconds, options.tracesTimeout)
+        assertEquals(10.seconds, options.metricsTimeout)
+        assertEquals(10.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_PROTOBUF, options.logsProtocol)
+    }
+
+    @Test
+    fun options_usesFallbacks() {
+        val data = hashMapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "HONEYCOMB_API_ENDPOINT" to "http://example.com:1234",
+            "OTEL_SERVICE_NAME" to "service",
+            "OTEL_RESOURCE_ATTRIBUTES" to "resource=aaa",
+            "OTEL_TRACES_SAMPLER" to "sampler",
+            "OTEL_TRACES_SAMPLER_ARG" to "arg",
+            "OTEL_PROPAGATORS" to "propagators",
+            "OTEL_EXPORTER_OTLP_HEADERS" to "header=bbb",
+            "OTEL_EXPORTER_OTLP_TIMEOUT" to 30000,
+            "OTEL_EXPORTER_OTLP_PROTOCOL" to "http/json",
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+
+        assertEquals("service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "service",
+                "resource" to "aaa",
+                "honeycomb.distro.version" to "0.0.1-alpha",
+                "honeycomb.distro.runtime_version" to "unknown",
+            ),
+            options.resourceAttributes
+        )
+
+        assertEquals("sampler", options.tracesSampler)
+        assertEquals("arg", options.tracesSamplerArg)
+        assertEquals("propagators", options.propagators)
+
+        assertEquals("http://example.com:1234/v1/traces", options.tracesEndpoint)
+        assertEquals("http://example.com:1234/v1/metrics", options.metricsEndpoint)
+        assertEquals("http://example.com:1234/v1/logs", options.logsEndpoint)
+
+        val expectedHeaders = mapOf(
+            "header" to "bbb",
+            "x-honeycomb-team" to "key",
+            "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+        )
+        assertEquals(expectedHeaders, options.tracesHeaders)
+        assertEquals(expectedHeaders, options.metricsHeaders)
+        assertEquals(expectedHeaders, options.logsHeaders)
+
+        assertEquals(30.seconds, options.tracesTimeout)
+        assertEquals(30.seconds, options.metricsTimeout)
+        assertEquals(30.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_JSON, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.logsProtocol)
+    }
+
+    @Test
+    fun options_usesAllValues() {
+        val data = hashMapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "HONEYCOMB_DATASET" to "dataset",
+            "HONEYCOMB_METRICS_DATASET" to "metrics",
+            "HONEYCOMB_TRACES_APIKEY" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "HONEYCOMB_METRICS_APIKEY" to "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+            "HONEYCOMB_LOGS_APIKEY" to "cccccccccccccccccccccccccccccccc",
+            "HONEYCOMB_TRACES_ENDPOINT" to "http://traces.example.com:1234",
+            "HONEYCOMB_METRICS_ENDPOINT" to "http://metrics.example.com:1234",
+            "HONEYCOMB_LOGS_ENDPOINT" to "http://logs.example.com:1234",
+            "SAMPLE_RATE" to 42,
+            "DEBUG" to true,
+            "OTEL_SERVICE_NAME" to "service",
+            "OTEL_RESOURCE_ATTRIBUTES" to "resource=aaa",
+            "OTEL_TRACES_SAMPLER" to "sampler",
+            "OTEL_TRACES_SAMPLER_ARG" to "arg",
+            "OTEL_PROPAGATORS" to "propagators",
+            "OTEL_EXPORTER_OTLP_TIMEOUT" to 30000,
+            "OTEL_EXPORTER_OTLP_PROTOCOL" to "http/json",
+            "OTEL_EXPORTER_OTLP_TRACES_HEADERS" to "header=ttt",
+            "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT" to 40000,
+            "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL" to "http/json",
+            "OTEL_EXPORTER_OTLP_METRICS_HEADERS" to "header=mmm",
+            "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT" to 50000,
+            "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL" to "http/json",
+            "OTEL_EXPORTER_OTLP_LOGS_HEADERS" to "header=lll",
+            "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT" to 60000,
+            "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL" to "http/json",
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+
+        assertEquals("service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "service",
+                "resource" to "aaa",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ), options.resourceAttributes
+        )
+
+        assertEquals("sampler", options.tracesSampler)
+        assertEquals("arg", options.tracesSamplerArg)
+        assertEquals("propagators", options.propagators)
+
+        assertEquals("http://traces.example.com:1234", options.tracesEndpoint)
+        assertEquals("http://metrics.example.com:1234", options.metricsEndpoint)
+        assertEquals("http://logs.example.com:1234", options.logsEndpoint)
+
+        assertEquals(
+            mapOf(
+                "header" to "ttt",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "mmm",
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "lll",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "cccccccccccccccccccccccccccccccc",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.logsHeaders
+        )
+
+        assertEquals(40.seconds, options.tracesTimeout)
+        assertEquals(50.seconds, options.metricsTimeout)
+        assertEquals(60.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_JSON, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.logsProtocol)
+
+        assertEquals(42, options.sampleRate)
+        assertTrue(options.debug)
+    }
+
+    @Test
+    fun options_usesSetValues() {
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(emptyMap<String, Any?>()))
+            .setDataset("dataset")
+            .setMetricsDataset("metrics")
+            .setTracesApiKey("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+            .setMetricsApiKey("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+            .setLogsApiKey("cccccccccccccccccccccccccccccccc")
+            .setTracesApiEndpoint("http://traces.example.com:1234")
+            .setMetricsApiEndpoint("http://metrics.example.com:1234")
+            .setLogsApiEndpoint("http://logs.example.com:1234")
+            .setSampleRate(42)
+            .setDebug(true)
+            .setServiceName("service")
+            .setResourceAttributes(mapOf("resource" to "aaa"))
+            .setTracesSampler("sampler")
+            .setTracesSamplerArg("arg")
+            .setPropagators("propagators")
+            .setTracesTimeout(40.seconds)
+            .setMetricsTimeout(50.seconds)
+            .setLogsTimeout(60.seconds)
+            .setTracesHeaders(mapOf("header" to "ttt"))
+            .setMetricsHeaders(mapOf("header" to "mmm"))
+            .setLogsHeaders(mapOf("header" to "lll"))
+            .setTracesProtocol(OtlpProtocol.HTTP_JSON)
+            .setMetricsProtocol(OtlpProtocol.HTTP_JSON)
+            .setLogsProtocol(OtlpProtocol.HTTP_JSON)
+            .build()
+
+        assertEquals("service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "service",
+                "resource" to "aaa",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ), options.resourceAttributes
+        )
+
+        assertEquals("sampler", options.tracesSampler)
+        assertEquals("arg", options.tracesSamplerArg)
+        assertEquals("propagators", options.propagators)
+
+        assertEquals("http://traces.example.com:1234", options.tracesEndpoint)
+        assertEquals("http://metrics.example.com:1234", options.metricsEndpoint)
+        assertEquals("http://logs.example.com:1234", options.logsEndpoint)
+
+        assertEquals(
+            mapOf(
+                "header" to "ttt",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "mmm",
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "lll",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "cccccccccccccccccccccccccccccccc",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.logsHeaders
+        )
+
+        assertEquals(40.seconds, options.tracesTimeout)
+        assertEquals(50.seconds, options.metricsTimeout)
+        assertEquals(60.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_JSON, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.logsProtocol)
+
+        assertEquals(42, options.sampleRate)
+        assertTrue(options.debug)
+    }
+
+    @Test
+    fun options_usesFallbackSetValues() {
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(emptyMap<String, Any?>()))
+            .setDataset("dataset")
+            .setMetricsDataset("metrics")
+            .setApiKey("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+            .setApiEndpoint("http://api.example.com:1234")
+            .setSampleRate(42)
+            .setDebug(true)
+            .setServiceName("service")
+            .setResourceAttributes(mapOf("resource" to "aaa"))
+            .setTracesSampler("sampler")
+            .setTracesSamplerArg("arg")
+            .setPropagators("propagators")
+            .setTimeout(30.seconds)
+            .setHeaders(mapOf("header" to "hhh"))
+            .setProtocol(OtlpProtocol.HTTP_JSON)
+            .build()
+
+        assertEquals("service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "service",
+                "resource" to "aaa",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ), options.resourceAttributes
+        )
+
+        assertEquals("sampler", options.tracesSampler)
+        assertEquals("arg", options.tracesSamplerArg)
+        assertEquals("propagators", options.propagators)
+
+        assertEquals("http://api.example.com:1234/v1/traces", options.tracesEndpoint)
+        assertEquals("http://api.example.com:1234/v1/metrics", options.metricsEndpoint)
+        assertEquals("http://api.example.com:1234/v1/logs", options.logsEndpoint)
+
+        assertEquals(
+            mapOf(
+                "header" to "hhh",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "hhh",
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "header" to "hhh",
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.logsHeaders
+        )
+
+        assertEquals(30.seconds, options.tracesTimeout)
+        assertEquals(30.seconds, options.metricsTimeout)
+        assertEquals(30.seconds, options.logsTimeout)
+
+        assertEquals(OtlpProtocol.HTTP_JSON, options.tracesProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.metricsProtocol)
+        assertEquals(OtlpProtocol.HTTP_JSON, options.logsProtocol)
+
+        assertEquals(42, options.sampleRate)
+        assertTrue(options.debug)
+    }
+
+    @Test
+    fun classicKey_causesDatasetHeader() {
+        val key = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(emptyMap<String, Any?>()))
+            .setDataset("dataset")
+            .setMetricsDataset("metrics")
+            .setApiKey(key)
+            .build()
+
+        val otlpVersion = io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.logsHeaders
+        )
+    }
+
+    @Test
+    fun ingestClassicKey_causesDatasetHeader() {
+        val key = "hcaic_7890123456789012345678901234567890123456789012345678901234"
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(emptyMap<String, Any?>()))
+            .setDataset("dataset")
+            .setMetricsDataset("metrics")
+            .setApiKey(key)
+            .build()
+
+        val otlpVersion = io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "dataset",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.logsHeaders
+        )
+    }
+
+    @Test
+    fun newKey_precludesDatasetHeader() {
+        val key = "not_classic"
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(emptyMap<String, Any?>()))
+            .setDataset("dataset")
+            .setMetricsDataset("metrics")
+            .setApiKey(key)
+            .build()
+
+        val otlpVersion = io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION
+        assertEquals(
+            mapOf(
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.tracesHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-dataset" to "metrics",
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.metricsHeaders
+        )
+        assertEquals(
+            mapOf(
+                "x-honeycomb-team" to key,
+                "x-otlp-version" to otlpVersion,
+            ), options.logsHeaders
+        )
+    }
+
+    @Test
+    fun header_isParsedCorrectly() {
+        val source = HoneycombOptionsMapSource(mapOf("data" to "foo=bar,baz=123%20456"))
+        val dict = source.getKeyValueList("data")
+        assertEquals(
+            mapOf(
+                "foo" to "bar",
+                "baz" to "123 456",
+            ), dict
+        )
+    }
+
+    @Test
+    fun options_headersAreMerged() {
+        val data = mapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "OTEL_EXPORTER_OTLP_HEADERS" to "foo=bar,baz=qux",
+            "OTEL_EXPORTER_OTLP_TRACES_HEADERS" to "foo=bar2,merged=yes"
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+        assertEquals(
+            mapOf(
+                "baz" to "qux",
+                "foo" to "bar2",
+                "merged" to "yes",
+                "x-honeycomb-team" to "key",
+                "x-otlp-version" to io.opentelemetry.android.BuildConfig.OTEL_ANDROID_VERSION,
+            ), options.tracesHeaders
+        )
+    }
+
+    @Test
+    fun options_serviceNameTakesPrecedence() {
+        val data = mapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "OTEL_SERVICE_NAME" to "explicit_name",
+            "OTEL_RESOURCE_ATTRIBUTES" to "service.name=resource_name"
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+        assertEquals("explicit_name", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "resource_name",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ), options.resourceAttributes
+        )
+    }
+
+    @Test
+    fun options_fallsBackToServiceNameFromResourceAttributes() {
+        val data = mapOf<String, Any?>(
+            "HONEYCOMB_API_KEY" to "key",
+            "OTEL_RESOURCE_ATTRIBUTES" to "service.name=better"
+        )
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+        assertEquals("better", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "better",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ),
+            options.resourceAttributes,
+        )
+    }
+
+    @Test
+    fun options_hasServiceNameDefault() {
+        val data = mapOf<String, Any?>("HONEYCOMB_API_KEY" to "key")
+        val options = HoneycombOptions.Builder(HoneycombOptionsMapSource(data)).build()
+        assertEquals("unknown_service", options.serviceName)
+        assertEquals(
+            mapOf(
+                "service.name" to "unknown_service",
+                "honeycomb.distro.version" to BuildConfig.HONEYCOMB_DISTRO_VERSION,
+                "honeycomb.distro.runtime_version" to "unknown",
+            ), options.resourceAttributes
+        )
+    }
+
+    @Test
+    fun options_throwsOnMalformedKeyValueString() {
+        val source = HoneycombOptionsMapSource(
+            mapOf(
+                "HONEYCOMB_API_KEY" to "key",
+                "data" to "foo=bar,baz"
+            )
+        )
+        assertThrows(HoneycombException::class.java) {
+            source.getKeyValueList("data")
+        }
+    }
+
+    @Test
+    fun options_throwsOnUnsupportedProtocol() {
+        val source = HoneycombOptionsMapSource(
+            mapOf<String, Any?>(
+                "HONEYCOMB_API_KEY" to "key",
+                "OTEL_TRACES_EXPORTER" to "not a protocol"
+            )
+        )
+        assertThrows(HoneycombException::class.java) {
+            HoneycombOptions.Builder(source).build()
+        }
+    }
+}
+
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 03b86a8..9dae532 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,23 +1,27 @@
 [versions]
 agp = "8.5.0"
-kotlin = "1.9.0"
 coreKtx = "1.13.1"
+desugarLibs = "2.0.4"
+espressoCore = "3.6.1"
 junit = "4.13.2"
 junitVersion = "1.2.1"
-espressoCore = "3.6.1"
-appcompat = "1.7.0"
-material = "1.12.0"
+kotlin = "1.9.0"
+opentelemetry = "1.40.0"
+opentelemetryAndroid = "0.6.0-alpha"
+
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
-junit = { group = "junit", name = "junit", version.ref = "junit" }
-androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
-androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
-material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+desugar-jdk-libs = { module = "com.android.tools:desugar_jdk_libs", version.ref = "desugarLibs" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+opentelemetry-android-agent = { module = "io.opentelemetry.android:android-agent", version.ref = "opentelemetryAndroid" }
+opentelemetry-api = { module = "io.opentelemetry:opentelemetry-api", version.ref = "opentelemetry"  }
+opentelemetry-sdk = { module = "io.opentelemetry:opentelemetry-sdk", version.ref = "opentelemetry"  }
+opentelemetry-exporter-otlp = { module = "io.opentelemetry:opentelemetry-exporter-otlp", version.ref = "opentelemetry"  }
 
 [plugins]
-android-application = { id = "com.android.application", version.ref = "agp" }
-jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 android-library = { id = "com.android.library", version.ref = "agp" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }