### Simple SDK Configuration Example

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Demonstrates a basic configuration for exporting spans and metrics using OTLP to a collector service. This setup includes default samplers, ID generators, resource, clock, and W3C trace context propagator.

```java
class HelloWorld {
  public static void main(String[] args) {
    SdkTracerProvider tracerProvider = 
        SdkTracerProvider.builder() 
            .addSpanProcessor(
                BatchSpanProcessor.builder(
                    OtlpGrpcSpanExporter.builder()
                        .setEndpoint("https://collector-service:4317")
                        .build())
                    .build())
            .build();

    OpenTelemetrySdk openTelemetry = 
        OpenTelemetrySdk.builder()
            .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
            .setTracerProvider(tracerProvider)
            .buildAndRegisterGlobal();

    PeriodicMetricReaderFactory periodicMetricReaderFactory = 
            PeriodicMetricReader.create(
                OtlpGrpcMetricExporter.builder()
                    .setEndpoint("https://collector-service:4317")
                    .build(), 
                Duration.ofMillis(1000));

    SdkMeterProvider sdkMeterProvider = 
            SdkMeterProvider.builder()
                .registerMetricReader(periodicMetricReaderFactory)
                .buildAndRegisterGlobal();
 }
}
```

--------------------------------

### Initialize and install JaegerRemoteSampler

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/sdk-extensions/jaeger-remote-sampler/README.md

Configures the sampler with a service name and integrates it into the SdkTracerProvider.

```java
JaegerRemoteSampler sampler = JaegerRemoteSampler.builder()
    .setServiceName("my-service")
    .build();
return SdkTracerProvider.builder()
    ...
    .setSampler(sampler)
    .build();
```

--------------------------------

### Set Up Pre-commit Hook for Formatting

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/other-tasks.md

Install a pre-commit hook to automatically run `spotlessApply` for code formatting. Copy or symlink the hook script into your project's .git/hooks/ directory.

```bash
cp buildscripts/pre-commit .git/hooks/pre-commit
```

```bash
ln -s ../../buildscripts/pre-commit .git/hooks/pre-commit
```

--------------------------------

### Initialize Partial SDK with DefaultOpenTelemetry

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Use DefaultOpenTelemetry.builder() to initialize a partial SDK when implementing specific signals without the full SDK. This example shows setting a TracerSdkProvider and a MicrometerProvider.

```java
@Bean
public OpenTelemetry openTelemetry() {
  return DefaultOpenTelemetry.builder()
    .setTraceProvider(TracerSdkProvider.builder().build())
    .setMeterProvider(MicrometerProvider.builder().build())
    .build();
}
```

--------------------------------

### Mockito Mocking Setup

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/testing-patterns.md

Configure Mockito for mocking dependencies in tests using @ExtendWith(MockitoExtension.class) and @Mock annotations.

```java
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class MyTest {
  @Mock MetricReader reader;
}
```

--------------------------------

### Common Gradle Build Tasks

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/build.md

Use these commands to manage code formatting, run tests and static analysis, or build the project. Ensure you have Java 21+ installed.

```bash
# Fix formatting violations
./gradlew spotlessApply
```

```bash
# Run checks only (tests + static analysis + formatting verification)
./gradlew check
```

```bash
# Build, run tests, static analysis, and check formatting
./gradlew build
```

--------------------------------

### Run GraalVM Native Image Tests

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/other-tasks.md

Execute integration tests for GraalVM native images using Gradle. Requires a GraalVM JDK with native-image installed. Use specific flags to prevent concurrency issues.

```bash
./gradlew nativeTest --no-configuration-cache --no-parallel
```

--------------------------------

### MeterProvider Interface

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.10.0_vs_1.9.0/opentelemetry-api.txt

The MeterProvider interface is the entry point for accessing meters and configuring metric collection. It provides methods to get a Meter instance and to build new meters.

```APIDOC
## MeterProvider Interface

### Description
The MeterProvider interface is the central interface for accessing meters and configuring metric collection. It allows retrieval of Meter instances and provides functionality to build new meters.

### Methods

- **get**(java.lang.String name): Returns a Meter instance with the given name.
- **meterBuilder**(java.lang.String name): Returns a MeterBuilder for creating a new Meter.
- **noop**(): Returns a no-operation MeterProvider that does nothing.
- **getMeter**(java.lang.String name): Returns a Meter instance with the given name. (Modified in OpenTelemetry API)
- **getMeterProvider**(): Returns the MeterProvider instance. (Modified in OpenTelemetry API)

```

--------------------------------

### Example of Buggy Mutable SDK Configuration

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

This Java code demonstrates a potential issue with mutable SDK configurations where business logic can directly update the global trace configuration, affecting other services unexpectedly. This highlights the need for immutability or controlled mutability.

```java
class SleuthUsingService {

  @Inject
  private OpenTelemetry openTelemetry;

  public void doLogic() {
    // My logic is important, so always sample it!
    OpenTelemetrySdk.getTracerManagement().updateTraceConfig(config -> config.setSampler(ALWAYS_ON));
    // This service was able to affect other services, even though Sleuth intends to
    // "manage the SDK". Unlike the javaagent, it can't block access to SDK methods we may provide.
    doSampledLogicWhileOtherServicesAlsoGetSampled();
  }
}
```

--------------------------------

### Model.Batch Static Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.7.0_vs_1.6.0/opentelemetry-exporter-jaeger-proto.txt

Contains static utility methods for the Model.Batch class, such as getting the parser.

```APIDOC
## Model.Batch Static Utilities

### Description
Provides static utility methods for `Model.Batch`.

### Methods

- `public static com.google.protobuf.Parser parser()`
```

--------------------------------

### Initialize Partial SDK with OpenTelemetrySdkWithMicrometer

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

An alternative method for initializing a partial SDK, specifically demonstrating integration with Micrometer. This builder allows adding span exporters and setting the meter registry.

```java
@Bean
public OpenTelemetry openTelemetry() {
  return OpenTelemetrySdkWithMicrometer.builder()
    .addSpanExporter()
    .setMeterRegistry()
    .build();
}
```

--------------------------------

### New Interface: CardinalityLimitSelector

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.44.0_vs_1.43.0/opentelemetry-sdk-metrics.txt

Introduces a new functional interface for selecting cardinality limits, with a default implementation and a method to get the limit based on InstrumentType.

```APIDOC
## NEW INTERFACE: PUBLIC ABSTRACT io.opentelemetry.sdk.metrics.export.CardinalityLimitSelector

### Description
This interface defines a strategy for determining the cardinality limit for metrics. It is a functional interface, meaning it can be implemented using lambda expressions.

### Methods
- **defaultCardinalityLimitSelector()** (PUBLIC STATIC): Returns a default implementation of the CardinalityLimitSelector.
- **getCardinalityLimit**(io.opentelemetry.sdk.metrics.InstrumentType) (PUBLIC ABSTRACT): Abstract method to get the cardinality limit for a given InstrumentType.
```

--------------------------------

### Set Release Credentials and Execute Gradle Task

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/RELEASING.md

Set the required environment variables for Sonatype and GPG credentials, define the release version, and then execute the Gradle final task for releasing.

```sh
export SONATYPE_USER=my_maven_user
export SONATYPE_KEY=my_maven_password
export GPG_PRIVATE_KEY=$(cat ~/tmp/gpg.key.txt)
export GPG_PASSWORD=<gpg password>
export RELEASE_VERSION=2.4.5 # Set version you want to release
./gradlew final -Prelease.version=${RELEASE_VERSION}
```

--------------------------------

### Configure TracerSdkProvider Bean

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Sets up the TracerSdkProvider with various processors and exporters. Includes configuration for OTLP and Zipkin exporters, sampling, and span limits.

```java
    @Bean
    public TracerSdkProvider tracerProvider(Resource resource, Clock clock, MonitoringConfig config) {
        return SdkTracerProvider.builder()
            .setResource(resource)
            .setClock(clock)
            .addSpanProcessor(CustomAttributeAddingProcessor.create())
            .addSpanProcessor(CustomEventAddingProcessor.create())
            .addSpanProcessor(
                BatchSpanProcessor.builder(
                    OtlpGrpcSpanExporter.builder()
                        .setEndpoint(config.getOtlpExporter().getEndpoint())
                        .setTimeout(config.getOtlpExporter().getTimeout())
                        .build())
                    .setBatchQueueSize(config.getOtlpExporter().getQueueSize())
                    .setExporterTimeout(config.getOtlpExporter().getTimeout())
                    .build())
            .addSpanProcessor(
                SimpleSpanProcessor.create(
                    ZipkinSpanExporter.builder()
                        .setEndpoint(config.getZipkinExporter().getEndpoint())
                        .build()))
            .setSampler(
                config.getSamplingRatio() != 0
                    ? Sampler.traceIdRatioBased(config.getSamplingRatio())
                    : Sampler.parentBased(Sampler.alwaysOn()))
            .setSpanLimits(
                SpanLimits.builder().setMaxNumberOfAttributes(config.getMaxSpanAttributes()).build())
            .setIdGenerator(TimestampedIdGenerator.create())
            .build();
    }

```

--------------------------------

### Parse and Create OpenTelemetrySdk from YAML

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/sdk-extensions/declarative-config/README.md

Initialize OpenTelemetrySdk by parsing a YAML configuration file. Ensure the file stream is closed after use. Environment variable substitution is supported.

```java
File yamlConfigFile = new File("/path/to/config.yaml");
OpenTelemetrySdk openTelemetrySdk;
try (FileInputStream yamlConfigFileInputStream = new FileInputStream("/path/to/config.yaml")) {
  openTelemetrySdk = DeclarativeConfiguration.parseAndCreate(yamlConfigFileInputStream).getSdk();
}
// ...proceed with application after successful initialization of OpenTelemetrySdk
```

--------------------------------

### Use Tracer and Meter Directly

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Shows how to obtain and use Tracer and Meter instances directly from providers. This is less common than using SDK-configured beans.

```java
// Use tracer directly, not so common
@Component
public class MyService {

  private final Tracer tracer;
  private final Meter meter;

  @Inject
  public MyService(TracerProvider tracerProvider, MeterProvider meterProvider) {
    tracer = tracerProvider.get("my-service");
    meter = meterProvider.get("my-service");
  }

  public void doLogic() {
    Span span = tracer.spanBuilder("logic").startSpan();
    try (Scope ignored = span.makeCurrent()) {
      Thread.sleep(1000);
    } finally {
      span.end();
    }
  }
}

```

--------------------------------

### Configure OpenTelemetry Java SDK

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

This snippet demonstrates a comprehensive configuration of the OpenTelemetry Java SDK, including setting resources, clocks, span processors, exporters, samplers, span limits, ID generators, and propagators. It shows how to build and register global SDK instances, including configurations for different backends like Jaeger.

```java
class HelloWorld {
  public static void main(String[] args) {
    Resource resource = Resource.getDefault().merge(CoolResource.getDefault());
    Clock clock = AtomicClock.create();
    SdkTracerProvider tracerProvider = 
        SdkTracerProvider.builder()
            .setResource(resource)
            .setClock(clock)
            .addSpanProcessor(CustomAttributeAddingProcessor.create())
            .addSpanProcessor(CustomEventAddingProcessor.create())
            .addSpanProcessor(
                BatchSpanProcessor.builder(
                    OtlpGrpcSpanExporter.builder()
                        .setEndpoint("https://collector-service:4317")
                        .setTimeout(Duration.ofSeconds(10))
                        .build())
                    .setMaxExportBatchSize(10000)
                    .build())
            .addSpanProcessor(
                SimpleSpanProcessor.create(
                    ZipkinSpanExporter.builder()
                        .setEndpoint("https://zipkin-service:9411")
                        .build()))
            .setSampler(Sampler.traceIdRatioBased(0.5))
            .setSpanLimits(SpanLimits.builder().setMaxNumberOfAttributes(10).build())
            .setIdGenerator(TimestampedIdGenerator.create())
            .build();

    OpenTelemetrySdk openTelemetry = 
        OpenTelemetrySdk.builder()
            .setPropagators(
                ContextPropagators.create(
                    TextMapPropagator.composite(
                        W3CTraceContextPropagator.getInstance(),
                        B3Propagator.injectingSingleHeader())))
            .setTracerProvider(tracerProvider)
            .buildAndRegisterGlobal();

    OpenTelemetrySdk openTelemetryForJaegerBackend = 
        OpenTelemetrySdk.builder()
            .setPropagators(ContextPropagators.create(JaegerPropagator.getInstance()))
            .setTracerProvider(tracerProvider)
            .build();

    PeriodicMetricReaderFactory periodicMetricReaderFactory = 
        PeriodicMetricReader.create(
                OtlpGrpcMetricExporter.builder()
                    .setEndpoint("https://collector-service:4317")
                    .build(),
                Duration.ofMillis(1000));
    SdkMeterProvider meterProvider = 
        SdkMeterProvider.builder()
            .setResource(resource)
            .setClock(clock)
            .registerView(
                InstrumentSelector.builder()
                    .setInstrumentType(InstrumentType.COUNTER)
                    .build(),
                View.builder().build())
            .registerMetricReader(periodicMetricReaderFactory)
            .buildAndRegisterGlobal();
 }
}
```

--------------------------------

### Lazy OpenTelemetry Initialization for SDK Components

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Demonstrates how SDK components can implement a lazy initialization pattern for OpenTelemetry. Components accept OpenTelemetry lazily to ensure the SDK is fully built before telemetry is emitted.

```java
interface OpenTelemetryComponent {
  default void setOpenTelemetry(OpenTelemetry openTelemetry) {}
}
interface SpanExporter extends OpenTelemetryComponent {
}
public class BatchExporter implements SpanExporter {

  private volatile Tracer tracer;

  @Override
  public void setOpenTelemetry(OpenTelemetry openTelemetry) {
        tracer = openTelemetry.getTracerProvider().get("spanexporter");
  }

  @Override
  public void export() {
        Tracer tracer = this.tracer;
        if (tracer != null) {
          tracer.spanBuilder("export").startSpan();
        }
  }
}
public class OpenTelemetrySdkBuilder {
    public OpenTelemetrySdkBuilder addSpanExporter(SpanExporter exporter) {
        tracerProvider.addSpanExporter(exporter);
        components.add(exporter);
    }

    public OpenTelemetrySdkBuilder setSampler(Sampler sampler) {
        tracerProvider.setSampler(sampler);
        components.add(sampler);
    }

    public OpenTelemetry build() {
        OpenTelemetrySdk sdk = new OpenTelemetrySdk(tracerProvider.build(), meterProvider.build());
        for (OpenTelemetryComponent component : components) {
          component.setOpenTelemetry(sdk);
        }
    }
}
```

--------------------------------

### SdkMeterProvider Configuration

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.14.0_vs_1.13.0/opentelemetry-sdk-metrics.txt

The SdkMeterProvider is the entry point for creating meters and configuring the metrics SDK, including resource settings and metric readers.

```APIDOC
## SdkMeterProvider Configuration

### Description
Provides the builder pattern to instantiate and configure an SdkMeterProvider, which manages the lifecycle of meters and metric collection.

### Methods
- **builder()**: Returns a new SdkMeterProviderBuilder.
- **registerMetricReader(MetricReader)**: Registers a reader for exporting metrics.
- **registerView(InstrumentSelector, View)**: Configures a custom view for specific instruments.
- **setResource(Resource)**: Sets the resource associated with the metrics.
- **build()**: Constructs the SdkMeterProvider instance.
```

--------------------------------

### Run W3C Context Propagation Integration Test

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/integration-tests/tracecontext/README.md

Execute the integration test script for W3C Trace Context propagation. Ensure all environmental requirements are met before running.

```shell
./tracecontext-integration-test.sh
```

--------------------------------

### Initialize JUL Logger

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/general-patterns.md

Instantiate a java.util.logging.Logger for production source sets. Do not use SLF4J or other frameworks in src/main/.

```java
private static final Logger LOGGER = Logger.getLogger(MyClass.class.getName());
```

--------------------------------

### Configure MeterSdkProvider Bean (Basic)

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Configures a MeterSdkProvider with a basic view for counters. This is a simpler configuration without a specific metric reader.

```java
    @Bean
    public MeterSdkProvider meterProvider(Resource resource, Clock clock) {
        return SdkMeterProvider.builder()
            .setResource(resource)
            .setClock(clock)
            .registerView(
                InstrumentSelector.builder()
                    .setInstrumentType(InstrumentType.COUNTER)
                    .build(),
                View.builder().build())
            .build();
    }

```

--------------------------------

### Configure Composite Builds in Gradle

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/other-tasks.md

Set up Gradle composite builds to test local changes against other projects. This involves generating substitution mappings and including them in the consuming project's settings.gradle.kts.

```kotlin
includeBuild("PATH/TO/OPENTELEMETRY-JAVA/ROOT/DIRECTORY") {
  // paste from generated substitutions.gradle.kts
  dependencySubstitution {
    substitute(module("io.opentelemetry:opentelemetry-api")).using(project(":api:all"))
    substitute(module("io.opentelemetry:opentelemetry-sdk")).using(project(":sdk:all"))
    // ...
  }
}
```

--------------------------------

### Create OpenTracing Shim Tracer with Custom Propagators

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/opentracing-shim/README.md

Create an OpenTracing Tracer shim using a specific OpenTelemetry instance, a text map propagator, and an HTTP propagator. This allows for fine-grained control over context propagation.

```java
Tracer tracer = OpenTracingShim.createTracerShim(openTelemetry, textMapPropagator, httpPropagator);
```

--------------------------------

### Configure Maven for Snapshots

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/README.md

Configure Maven to use the Sonatype snapshot repository and include the OpenTelemetry BOM and API for snapshot versions.

```xml
<project>
    <repositories>
      <repository>
        <id>sonatype-snapshot-repository</id>
        <url>https://central.sonatype.com/repository/maven-snapshots/</url>
      </repository>
    </repositories>
    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>io.opentelemetry</groupId>
          <artifactId>opentelemetry-bom</artifactId>
          <version>1.64.0-SNAPSHOT</version>
          <type>pom</type>
          <scope>import</scope>
        </dependency>
      </dependencies>
    </dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-api</artifactId>
      </dependency>
    </dependencies>
  </project>
```

--------------------------------

### Span Lifecycle Handling in Java

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/rationale.md

Demonstrates the correct way to manage a Span's lifecycle, including exception recording and ensuring the span is always ended, which is not possible with try-with-resources.

```java
Span span = tracer.spanBuilder("someWork").startSpan();
try (Scope scope = TracingContextUtils.currentContextWith(span)) {
    // Do things.
} catch (Exception ex) {
    span.recordException(ex);
} finally {
    span.end();
}
```

--------------------------------

### Configure Gradle for Snapshots

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/README.md

Configure Gradle to use the Sonatype snapshot repository and include the OpenTelemetry BOM and API for snapshot versions.

```groovy
repositories {
    maven { url 'https://central.sonatype.com/repository/maven-snapshots/' }
}

dependencies {
  implementation platform("io.opentelemetry:opentelemetry-bom:1.64.0-SNAPSHOT")
  implementation('io.opentelemetry:opentelemetry-api')
}
```

--------------------------------

### Configure MeterSdkProvider Bean (with PeriodicMetricReader)

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Configures a MeterSdkProvider including a PeriodicMetricReaderFactory. This allows for scheduled reading of metrics.

```java
    @Bean
    public MeterSdkProvider meterProvider(Resource resource, Clock clock, PeriodicMetricReaderFactory periodicMetricReaderFactory) {
        return SdkMeterProvider.builder()
            .setResource(resource)
            .setClock(clock)
            .registerView(
                InstrumentSelector.builder()
                    .setInstrumentType(InstrumentType.COUNTER)
                    .build(),
                View.builder().build())
            .registerMetricReader(periodicMetricReaderFactory)
            .build();
    }

```

--------------------------------

### AutoConfiguredOpenTelemetrySdk API

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.28.0_vs_1.27.0/opentelemetry-sdk-extension-autoconfigure.txt

Provides methods to initialize and build the OpenTelemetry SDK using autoconfiguration patterns.

```APIDOC
## AutoConfiguredOpenTelemetrySdk

### Description
Main entry point for autoconfiguring the OpenTelemetry SDK. Allows for programmatic initialization and access to the configured SDK instance.

### Methods
- **builder()**: Returns a new AutoConfiguredOpenTelemetrySdkBuilder.
- **initialize()**: Initializes the SDK with default autoconfiguration.
- **getOpenTelemetrySdk()**: Returns the configured OpenTelemetrySdk instance.
```

--------------------------------

### SdkLoggerProviderBuilder Configuration Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.27.0_vs_1.26.0/opentelemetry-sdk-logs.txt

Methods to configure log limits and resource definitions for the SdkLoggerProviderBuilder.

```APIDOC
## PUBLIC SdkLoggerProviderBuilder setLogLimits(Supplier)

### Description
Sets the log limits for the logger provider using a supplier.

### Method
Java Method

### Parameters
- **supplier** (java.util.function.Supplier) - Required - The supplier providing the log limits.

## PUBLIC SdkLoggerProviderBuilder setResource(Resource)

### Description
Sets the resource associated with the logger provider.

### Method
Java Method

### Parameters
- **resource** (io.opentelemetry.sdk.resources.Resource) - Required - The resource to be associated with the logger provider.
```

--------------------------------

### New Class: ExplicitBucketHistogramOptions.Builder

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.60.0_vs_1.59.0/opentelemetry-sdk-metrics.txt

Builder class for `ExplicitBucketHistogramOptions`.

```APIDOC
## NEW CLASS: PUBLIC ABSTRACT STATIC io.opentelemetry.sdk.metrics.ExplicitBucketHistogramOptions$Builder

### Description
This is a builder class used to construct `ExplicitBucketHistogramOptions` objects.

### Methods
- `build()`: Constructs and returns the `ExplicitBucketHistogramOptions` object.
- `setBucketBoundaries(java.util.List<java.lang.Double>)`: Sets the bucket boundaries.
- `setRecordMinMax(boolean)`: Sets whether to record minimum and maximum values.

### Parameters
- `bucketBoundaries` (java.util.List<java.lang.Double>) - Required - The boundaries for the histogram buckets.
- `recordMinMax` (boolean) - Required - Whether to record minimum and maximum values.
```

--------------------------------

### Configure OpenTelemetry SDK Bean

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Builds and registers the global OpenTelemetry SDK instance. Configures propagators for trace context propagation.

```java
    @Bean
    public OpenTelemetry openTelemetry(SdkTracerProvider tracerProvider, SdkMeterProvider meterProvider) {
        GlobalMeterProvider.set(meterProvider);
        return OpenTelemetrySdk.builder()
            .setPropagators(
                ContextPropagators.create(
                    TextMapPropagator.composite(
                        W3CTraceContextPropagator.getInstance(),
                        B3Propagator.injectingSingleHeader())))
            .setTracerProvider(tracerProvider)
            .buildAndRegisterGlobal();
    }

```

--------------------------------

### Lazy Tracer Injection with Dependency Injection Framework

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Illustrates how to use a dependency injection framework (like Spring) to lazily inject a Tracer into custom components. This approach simplifies integration for framework authors.

```java
@Component
public class MonitoringModule {

    @Bean
    @ForSpanExporter
    public Tracer tracer(TracerProvider tracerProvider) {
    return tracerProvider.get("spanexporter");
    }
}

@Component
public class MyExporter implements SpanExporter {

    private Lazy<Tracer> tracer;

    @Inject
    public MyExporter(@ForSpanExporter Lazy<Tracer> tracer) {
    this.tracer = tracer;
    }

    @Override
    public void export() {
    tracer.get().spanBuilder("export").startSpan();
    }
}
```

--------------------------------

### io.opentelemetry.sdk.common.export.HttpSenderProvider

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.59.0_vs_1.58.0/opentelemetry-sdk-common.txt

Interface for providing instances of HttpSender.

```APIDOC
## io.opentelemetry.sdk.common.export.HttpSenderProvider

### Description
An interface responsible for creating `HttpSender` instances based on a given configuration.

### Methods
- **createSender(io.opentelemetry.sdk.common.export.HttpSenderConfig config)**: Creates and returns an `HttpSender` configured with the provided `HttpSenderConfig`.
```

--------------------------------

### New Methods in RateLimitingSamplingStrategy.Builder

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.27.0_vs_1.26.0/opentelemetry-sdk-extension-jaeger-remote-sampler.txt

Introduces new methods for cloning and setting fields on the RateLimitingSamplingStrategy builder.

```APIDOC
## New Methods in RateLimitingSamplingStrategy.Builder

### Description
These methods allow for cloning the builder and setting specific fields, including repeated fields.

### Methods
- `clone()`: Creates a new instance of the builder with the same configuration.
- `setField(com.google.protobuf.Descriptors$FieldDescriptor, java.lang.Object)`: Sets a field on the builder.
- `setRepeatedField(com.google.protobuf.Descriptors$FieldDescriptor, int, java.lang.Object)`: Sets a repeated field at a specific index.
```

--------------------------------

### ResourceConfiguration API

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.28.0_vs_1.27.0/opentelemetry-sdk-extension-autoconfigure.txt

Utility class for creating resources based on environment configuration.

```APIDOC
## ResourceConfiguration

### Description
Utility for creating OpenTelemetry Resources from environment variables and configuration properties.

### Methods
- **createEnvironmentResource()**: Creates a resource based on the current environment.
- **createEnvironmentResource(ConfigProperties)**: Creates a resource based on provided configuration properties.
```

--------------------------------

### New Method for Wrapping Suppliers in OpenTelemetry Java

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.12.0_vs_1.11.0/opentelemetry-context.txt

This method is used to wrap Suppliers, enabling context propagation for the supplier's execution. The OpenTelemetry SDK must be initialized.

```java
+++! NEW METHOD: PUBLIC(+) java.util.function.Supplier wrapSupplier(java.util.function.Supplier)
```

--------------------------------

### ViewBuilder Configuration Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.14.0_vs_1.13.0/opentelemetry-sdk-metrics.txt

Methods to configure a metric view using the ViewBuilder class.

```APIDOC
## ViewBuilder Configuration

### Description
Methods to customize the properties of a metric view, including its name, description, and attribute filtering logic.

### Methods
- **setName(String name)**: Sets the name of the metric view.
- **setDescription(String description)**: Sets the description of the metric view.
- **setAttributeFilter(Predicate filter)**: Sets a predicate to filter attributes for the metric view.
```

--------------------------------

### Create OpenTracing Shim Tracer from OpenTelemetry Instance

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/opentracing-shim/README.md

Use this method to create an OpenTracing Tracer shim from an existing OpenTelemetry instance. This is useful for integrating OpenTelemetry with applications that rely on the OpenTracing API.

```java
Tracer tracer = OpenTracingShim.createTracerShim(openTelemetry);
```

--------------------------------

### Configure AuthServiceStub Bean

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Creates an AuthServiceStub using a blocking stub with tracing interceptor. Requires OpenTelemetry and AuthConfig.

```java
    @Bean
    public AuthServiceStub authService(@ForJaeger OpenTelemetry openTelemetry, AuthConfig config) {
        return AuthServiceGrpc.newBlockingStub(ManagedChannelBuilder.forEndpoint(config.getEndpoint()))
          .withInterceptor(TracingClientInterceptor.create(openTelemetry));
    }

```

--------------------------------

### io.opentelemetry.sdk.extension.resources.ContainerResourceProvider

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.5.0_vs_1.4.1/opentelemetry-sdk-extension-resources.txt

Provider class for creating container resources based on configuration properties.

```APIDOC
## ContainerResourceProvider

### Description
A provider class used to instantiate container resources.

### Methods
- **createResource(ConfigProperties config)** - Creates a Resource based on the provided configuration properties.
```

--------------------------------

### New Methods for Wrapping Consumers in OpenTelemetry Java

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.12.0_vs_1.11.0/opentelemetry-context.txt

These methods are used to wrap existing Consumers with OpenTelemetry context propagation capabilities. Ensure the OpenTelemetry SDK is initialized before use.

```java
+++! NEW METHOD: PUBLIC(+) java.util.function.Consumer wrapConsumer(java.util.function.Consumer)
```

```java
+++! NEW METHOD: PUBLIC(+) java.util.function.BiConsumer wrapConsumer(java.util.function.BiConsumer)
```

--------------------------------

### Apply OTel Java Conventions Plugin

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/gradle-conventions.md

Apply the base `otel.java-conventions` plugin for Java toolchain, Checkstyle, Spotless, Error Prone, and test configuration.

```kotlin
plugins {
  id("otel.java-conventions")
  id("otel.publish-conventions")
}
```

--------------------------------

### Model: Trace$ProcessMapping

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.7.0_vs_1.6.0/opentelemetry-exporter-jaeger-proto.txt

The ProcessMapping class provides methods to access process information and handle protobuf serialization for Jaeger trace data.

```APIDOC
## Class: io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Trace$ProcessMapping

### Description
Represents a mapping between a process ID and process details within a Jaeger trace. This class provides standard protobuf-based accessors and parsing utilities.

### Methods
- **getProcessId()** (String) - Returns the process ID.
- **getProcess()** (Model$Process) - Returns the associated process details.
- **hasProcess()** (boolean) - Checks if process details are present.
- **getSerializedSize()** (int) - Returns the serialized size of the object.
- **getParserForType()** (Parser) - Returns the protobuf parser for this type.

### Parsing Methods
- **parseFrom(byte[])** - Parses the object from a byte array.
- **parseFrom(InputStream)** - Parses the object from an input stream.
- **parseFrom(ByteBuffer)** - Parses the object from a byte buffer.

### Builder
- **newBuilder()** - Creates a new builder instance for constructing ProcessMapping objects.
```

--------------------------------

### Run JMH Benchmarks in OpenTelemetry Java

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/other-tasks.md

Execute all benchmarks for a specific module or a single benchmark class using Gradle. Ensure the JMH plugin is configured.

```bash
./gradlew :sdk:trace:jmh
```

```bash
./gradlew -PjmhIncludeSingleClass=BatchSpanProcessorBenchmark :sdk:trace:jmh
```

--------------------------------

### Run Javadoc Crawler

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/javadoc-crawler/README.md

Execute the Javadoc crawler task using Gradle. This task pulls artifacts from Maven Central and visits their corresponding pages on javadoc.io to trigger content loading.

```bash
./gradlew :javadoc-crawler:crawl
```

--------------------------------

### Configure Resource and Clock Beans

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/sdk-configuration-design.md

Defines beans for Resource and Clock, essential for SDK initialization. The Resource merges default and custom resources, while the Clock uses an atomic implementation.

```java
@Component
public class OpenTelemetryModule {
    @Bean
    public Resource resource() {
        return Resource.getDefault().merge(CoolResource.getDefault());
    }

    @Bean
    public Clock otelClock() {
        return AtomicClock.create();
    }

```

--------------------------------

### New Class: ExplicitBucketHistogramOptions

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.60.0_vs_1.59.0/opentelemetry-sdk-metrics.txt

Introduces the `ExplicitBucketHistogramOptions` class for configuring explicit bucket histograms.

```APIDOC
## NEW CLASS: PUBLIC ABSTRACT io.opentelemetry.sdk.metrics.ExplicitBucketHistogramOptions

### Description
This class provides options for configuring the explicit bucket histogram aggregation. It allows setting custom bucket boundaries and whether to record minimum and maximum values.

### Methods
- `builder()`: Static method to create a builder for `ExplicitBucketHistogramOptions`.
- `getBucketBoundaries()`: Returns the list of bucket boundaries.
- `getDefault()`: Static method to get the default configuration.
- `getRecordMinMax()`: Returns whether min/max values are recorded.
- `toBuilder()`: Creates a builder initialized with the current options.

### Parameters
- `bucketBoundaries` (java.util.List<java.lang.Double>) - Nullable - The boundaries for the histogram buckets.
- `recordMinMax` (boolean) - Whether to record minimum and maximum values.
```

--------------------------------

### ProxyOptions Class

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.36.0_vs_1.35.0/opentelemetry-sdk-common.txt

Details about the ProxyOptions class, including its constructors and methods.

```APIDOC
## Class: io.opentelemetry.sdk.common.export.ProxyOptions

### Description
Provides options for configuring proxy settings within the SDK.

### Methods

#### `create(ProxySelector)`
- **Description**: Creates a new ProxyOptions instance with the specified ProxySelector.
- **Method**: static
- **Parameters**:
  - `proxySelector` (java.net.ProxySelector) - Required - The proxy selector to use.

#### `create(InetSocketAddress)`
- **Description**: Creates a new ProxyOptions instance with the specified InetSocketAddress for the proxy.
- **Method**: static
- **Parameters**:
  - `proxyAddress` (java.net.InetSocketAddress) - Required - The address of the proxy.

#### `getProxySelector()`
- **Description**: Returns the configured ProxySelector.
- **Method**: public
- **Returns**:
  - `java.net.ProxySelector` - The proxy selector.

#### `toString()`
- **Description**: Returns a string representation of the ProxyOptions object.
- **Method**: public
- **Returns**:
  - `java.lang.String` - A string representation.
```

--------------------------------

### SdkLoggerProvider Class

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.27.0_vs_1.26.0/opentelemetry-sdk-logs.txt

The SdkLoggerProvider is the entry point for creating loggers and managing the lifecycle of log processing components.

```APIDOC
## SdkLoggerProvider Class

### Description
Provides access to Logger instances and manages the configuration of log record processors.

### Methods
- **builder()**: Returns a new SdkLoggerProviderBuilder.
- **get(String name)**: Retrieves a logger by name.
- **loggerBuilder(String name)**: Returns a builder for creating a logger.
- **forceFlush()**: Triggers a flush for all registered processors.
- **shutdown()**: Shuts down the provider and all associated processors.
```

--------------------------------

### Model$Trace$ProcessMapping

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.7.0_vs_1.6.0/opentelemetry-exporter-jaeger.txt

Details regarding the Model$Trace$ProcessMapping class, including its fields and methods for parsing and manipulation.

```APIDOC
## Model$Trace$ProcessMapping

### Description
Represents a mapping for process information within the Jaeger proto API v2.

### Method
N/A (This is a data model class)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A

### Available Methods

- `getProcess()`: Retrieves the associated Process object.
- `getProcessId()`: Retrieves the process ID as a String.
- `getProcessIdBytes()`: Retrieves the process ID as a ByteString.
- `getProcessOrBuilder()`: Retrieves the builder for the Process object.
- `hasProcess()`: Checks if a Process object is present.

### Parsing Methods

- `parseFrom(java.nio.ByteBuffer data)`: Parses from a ByteBuffer.
- `parseFrom(java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses from a ByteBuffer with an extension registry.
- `parseFrom(com.google.protobuf.ByteString data)`: Parses from a ByteString.
- `parseFrom(com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses from a ByteString with an extension registry.
- `parseFrom(byte[] data)`: Parses from a byte array.
- `parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses from a byte array with an extension registry.
- `parseFrom(java.io.InputStream input)`: Parses from an InputStream.
- `parseFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses from an InputStream with an extension registry.
- `parseFrom(com.google.protobuf.CodedInputStream input)`: Parses from a CodedInputStream.
- `parseFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses from a CodedInputStream with an extension registry.
- `parseDelimitedFrom(java.io.InputStream input)`: Parses a delimited message from an InputStream.
- `parseDelimitedFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`: Parses a delimited message from an InputStream with an extension registry.

### Builder Methods

- `newBuilder()`: Creates a new builder for ProcessMapping.
- `newBuilder(io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Trace$ProcessMapping prototype)`: Creates a new builder initialized with a prototype.
- `toBuilder()`: Converts the current ProcessMapping to a builder.

### Static Methods

- `getDefaultInstance()`: Returns the default instance of ProcessMapping.
- `getDescriptor()`: Returns the descriptor for ProcessMapping.
- `parser()`: Returns the parser for ProcessMapping.

### Exceptions
- `com.google.protobuf.InvalidProtocolBufferException`: Thrown by parsing methods if the input is not a valid protocol buffer.
- `java.io.IOException`: Thrown by parsing methods that read from streams if an I/O error occurs.
```

--------------------------------

### TestLogRecordData Builder Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.27.0_vs_1.26.0/opentelemetry-sdk-testing.txt

Methods for configuring log record data during testing scenarios.

```APIDOC
## TestLogRecordData Builder Methods

### Description
Methods to configure properties of a log record for testing purposes using the TestLogRecordData.Builder.

### Methods
- **setObservedTimestamp(long, TimeUnit)**: Sets the observed timestamp.
- **setResource(Resource)**: Sets the resource associated with the log record.
- **setSeverity(Severity)**: Sets the severity level of the log record.
- **setSeverityText(String)**: Sets the severity text.
- **setSpanContext(SpanContext)**: Sets the span context.
- **setTimestamp(Instant)**: Sets the timestamp using an Instant.
- **setTimestamp(long, TimeUnit)**: Sets the timestamp using long and TimeUnit.
- **setTotalAttributeCount(int)**: Sets the total count of attributes.
```

--------------------------------

### Incubating Internal Code Javadoc

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/general-patterns.md

Use this Javadoc comment for internal, experimental code that may be promoted to public API in the future. APIs are unstable and may change.

```java
// For incubating internal code that may be promoted to public API:
/**
 * This class is internal and is experimental. Its APIs are unstable and can change at any time.
 * Its APIs (or a version of them) may be promoted to the public stable API in the future, but
 * no guarantees are made.
 */
```

--------------------------------

### InstrumentationScopeInfo Class Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.12.0_vs_1.11.0/opentelemetry-sdk-common.txt

Methods for creating instances of InstrumentationScopeInfo and retrieving scope metadata.

```APIDOC
## Class: io.opentelemetry.sdk.common.InstrumentationScopeInfo

### Description
Represents the scope of instrumentation, providing metadata about the library or component that generated the telemetry.

### Methods
- **create(String name)**: Creates a new InstrumentationScopeInfo instance with the specified name.
- **create(String name, String version, String schemaUrl)**: Creates a new InstrumentationScopeInfo instance with the specified name, version, and schema URL.
- **empty()**: Returns an empty InstrumentationScopeInfo instance.
- **getName()**: Returns the name of the instrumentation scope.
- **getVersion()**: Returns the version of the instrumentation scope (Nullable).
- **getSchemaUrl()**: Returns the schema URL of the instrumentation scope (Nullable).
```

--------------------------------

### New Methods for Wrapping Functions in OpenTelemetry Java

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.12.0_vs_1.11.0/opentelemetry-context.txt

These methods allow wrapping existing Functions to enable context propagation within their execution. Proper SDK initialization is required.

```java
+++! NEW METHOD: PUBLIC(+) java.util.function.Function wrapFunction(java.util.function.Function)
```

```java
+++! NEW METHOD: PUBLIC(+) java.util.function.BiFunction wrapFunction(java.util.function.BiFunction)
```

--------------------------------

### Model.Process.Builder Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.7.0_vs_1.6.0/opentelemetry-exporter-jaeger-proto.txt

Provides methods for building and modifying a Model.Process object.

```APIDOC
## Model.Process.Builder

### Description
Methods for constructing and manipulating `io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder` objects.

### Methods

- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addAllTags(java.lang.Iterable)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addRepeatedField(com.google.protobuf.Descriptors$FieldDescriptor, java.lang.Object)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addTags(io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addTags(int, io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addTags(io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue$Builder)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder addTags(int, io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue$Builder)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue$Builder addTagsBuilder()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$KeyValue$Builder addTagsBuilder(int)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process build()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process buildPartial()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clear()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clearField(com.google.protobuf.Descriptors$FieldDescriptor)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clearOneof(com.google.protobuf.Descriptors$OneofDescriptor)`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clearServiceName()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clearTags()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process$Builder clone()`
- `public io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Process getDefaultInstanceForType()`
- `public void writeTo(com.google.protobuf.CodedOutputStream)`
  - Throws: `java.io.IOException`
```

--------------------------------

### Gradle Test Suite Configuration

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/testing-patterns.md

Configure test suites in Gradle using the JvmTestSuite API. Ensure all registered suites are wired into the 'check' task.

```kotlin
testing {
  suites {
    register<JvmTestSuite>("testIncubating") {
      dependencies {
        implementation(project(":api:incubator"))
      }
    }
  }
}

tasks {
  check {
    dependsOn(testing.suites) // wires all suites into check
  }
}
```

--------------------------------

### AutoConfigurationCustomizer Interface

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.9.0_vs_1.7.0/opentelemetry-sdk-extension-autoconfigure-spi.txt

The AutoConfigurationCustomizer interface allows for programmatic customization of the OpenTelemetry SDK's autoconfiguration.

```APIDOC
## Interface: io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer

### Description
Provides methods to customize the autoconfiguration of the OpenTelemetry SDK.

### Methods

- **addPropagatorCustomizer**(java.util.function.BiFunction)
  Adds a customizer for propagators.

- **addPropertiesSupplier**(java.util.function.Supplier)
  Adds a supplier for additional properties.

- **addResourceCustomizer**(java.util.function.BiFunction)
  Adds a customizer for resources.

- **addSamplerCustomizer**(java.util.function.BiFunction)
  Adds a customizer for samplers.

- **addSpanExporterCustomizer**(java.util.function.BiFunction)
  Adds a customizer for span exporters.
```

--------------------------------

### Apply OTel Java Conventions for Internal Modules

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/knowledge/gradle-conventions.md

Apply the base `otel.java-conventions` plugin for internal modules that are not published. This excludes the `otel.publish-conventions`.

```kotlin
plugins {
  id("otel.java-conventions")
  // no otel.publish-conventions
}
```

--------------------------------

### io.opentelemetry.sdk.extension.resources.ContainerResource

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.5.0_vs_1.4.1/opentelemetry-sdk-extension-resources.txt

Provides access to container-specific resource information.

```APIDOC
## ContainerResource

### Description
A final class representing container resources in the OpenTelemetry SDK.

### Methods
- **get()** (static) - Returns an instance of io.opentelemetry.sdk.resources.Resource.
```

--------------------------------

### Model Class Methods

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.7.0_vs_1.6.0/opentelemetry-exporter-jaeger-proto.txt

Details on the methods available for interacting with the Model class, including retrieving process information, trace data, and warnings.

```APIDOC
## Model Class Methods

### Description
Provides methods to access process information, trace details, and warnings within the Jaeger proto model.

### Methods

- **getProcessOrBuilder()** (io.opentelemetry.exporter.jaeger.proto.api_v2.Model$ProcessOrBuilder) - Retrieves the ProcessOrBuilder.
- **hasProcess()** (boolean) - Checks if process information is present.
- **getProcessMap(int)** (io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Trace$ProcessMapping) - Retrieves a specific ProcessMapping by index.
- **getProcessMapCount()** (int) - Returns the total number of ProcessMappings.
- **getProcessMapList()** (java.util.List) - Retrieves a list of all ProcessMappings.
- **getProcessMapOrBuilder(int)** (io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Trace$ProcessMappingOrBuilder) - Retrieves a ProcessMappingOrBuilder by index.
- **getProcessMapOrBuilderList()** (java.util.List) - Retrieves a list of all ProcessMappingOrBuilders.
- **getSpans(int)** (io.opentelemetry.exporter.jaeger.proto.api_v2.Model$Span) - Retrieves a specific Span by index.
- **getSpansCount()** (int) - Returns the total number of Spans.
- **getSpansList()** (java.util.List) - Retrieves a list of all Spans.
- **getSpansOrBuilder(int)** (io.opentelemetry.exporter.jaeger.proto.api_v2.Model$SpanOrBuilder) - Retrieves a SpanOrBuilder by index.
- **getSpansOrBuilderList()** (java.util.List) - Retrieves a list of all SpanOrBuilders.
- **getWarnings(int)** (java.lang.String) - Retrieves a specific warning message by index.
- **getWarningsBytes(int)** (com.google.protobuf.ByteString) - Retrieves a specific warning message as ByteString by index.
- **getWarningsCount()** (int) - Returns the total number of warning messages.
- **getWarningsList()** (java.util.List) - Retrieves a list of all warning messages.
```

--------------------------------

### New Class: Base2ExponentialHistogramOptions.Builder

Source: https://github.com/open-telemetry/opentelemetry-java/blob/main/docs/apidiffs/1.60.0_vs_1.59.0/opentelemetry-sdk-metrics.txt

Builder class for `Base2ExponentialHistogramOptions`.

```APIDOC
## NEW CLASS: PUBLIC ABSTRACT STATIC io.opentelemetry.sdk.metrics.Base2ExponentialHistogramOptions$Builder

### Description
This is a builder class used to construct `Base2ExponentialHistogramOptions` objects.

### Methods
- `build()`: Constructs and returns the `Base2ExponentialHistogramOptions` object.
- `setMaxBuckets(int)`: Sets the maximum number of buckets.
- `setMaxScale(int)`: Sets the maximum scale.
- `setRecordMinMax(boolean)`: Sets whether to record minimum and maximum values.

### Parameters
- `maxBuckets` (int) - Required - The maximum number of buckets.
- `maxScale` (int) - Required - The maximum scale.
- `recordMinMax` (boolean) - Required - Whether to record minimum and maximum values.
```