> ## Documentation Index
> Fetch the complete documentation index at: https://docs.odigos.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Enrich with OpenTelemetry API

export const language_0 = "Java";

Odigos will automatically instrument your {language_0} services and record semantic spans from popular modules. Many users find the automatic instrumentation data sufficient for their needs.

However, if there is anything specific to your application that you want to record, you can enrich the data by adding custom spans to your code.

This is sometimes referred to as `manual instrumentation`.

## Use Cases

Examples of custom spans you might want to add to your code include:

* Spans for the execution of some potentially heavy or slow computation in you service.
* Tracing for internal or third party libraries for which you don't have automatic or integrated instrumentation.
* Spans to describe some logical operations in your business logic that are meaningful in your domain.

## Required Dependencies

Add the following dependencies to your project:

<Tabs>
  <Tab title="Maven">
    ```xml theme={null}
    <project>
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>io.opentelemetry</groupId>
                    <artifactId>opentelemetry-bom</artifactId>
                    <version>1.35.0</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.opentelemetry</groupId>
                <artifactId>opentelemetry-api</artifactId>
            </dependency>
        </dependencies>
    </project>
    ```
  </Tab>

  <Tab title="Gradle">
    ```groovy theme={null}
    dependencyManagement {
        imports {
            mavenBom("io.opentelemetry:opentelemetry-bom:1.35.0")
        }
    }

    dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web");
    implementation("io.opentelemetry:opentelemetry-api");
    }

    ```

    If you are not using Spring and its `io.spring.dependency-management` dependency management plugin, install the OpenTelemetry BOM and API using Gradle dependencies only.

    ```groovy theme={null}
    dependencies {
        implementation(platform("io.opentelemetry:opentelemetry-bom:1.35.0"));
        implementation("io.opentelemetry:opentelemetry-api");
    }
    ```
  </Tab>
</Tabs>

## Creating Spans

To create a span, use the `Tracer` interface. The `Tracer` interface is the main entry point for the OpenTelemetry API. It allows you to create spans and manage the current span.
Acquire a `Tracer` instance using the `OpenTelemetry` class:

```java theme={null}
import io.opentelemetry.api.GlobalOpenTelemetry;

Tracer tracer = GlobalOpenTelemetry.getTracer("instrumentation-scope-name", "instrumentation-scope-version");
```

Now you can create a span using the `Tracer` instance:

```java theme={null}
Span span = tracer.spanBuilder("span-name").startSpan();

try (Scope scope = span.makeCurrent()) {
    // Your code goes here.
} finally {
    span.end();
}
```

## Additional Information

For more use cases, see the [OpenTelemetry Java API documentation](https://opentelemetry.io/docs/languages/java/instrumentation/#create-spans).