open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Promote log API / SDK to stable (#5341)

This commit is contained in:
jack-berg 2023-05-10 06:45:20 -05:00 committed by GitHub
parent 48785a358d
commit 8a917e036c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
45 changed files with 341 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -224,8 +224,7 @@ dependency as follows, replacing `{{artifact-id}}` with the value from the "Arti
| Component | Description | Artifact ID | Version | Javadoc |
|-----------------------------------|--------------------------------------------------------------------------------------------------------------------------------|----------------------------|-------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [API](./api/all) | OpenTelemetry API, including metrics, traces, baggage, context | `opentelemetry-api` | <!--VERSION_STABLE-->1.26.0<!--/VERSION_STABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-api.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api) |
| [Events API](./api/logs) | OpenTelemetry Event API for emitting events. | `opentelemetry-api-events` | <!--VERSION_UNSTABLE-->1.26.0-alpha<!--/VERSION_UNSTABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-api-events.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api-events) |
| [Logs API](./api/logs) | OpenTelemetry Log API for bridging log frameworks (NOT a replacement for application logging frameworks like SLF4J, JUL, etc.) | `opentelemetry-api-logs` | <!--VERSION_UNSTABLE-->1.26.0-alpha<!--/VERSION_UNSTABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-api-logs.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api-logs) |
| [Events API](./api/events) | OpenTelemetry Event API for emitting events. | `opentelemetry-api-events` | <!--VERSION_UNSTABLE-->1.26.0-alpha<!--/VERSION_UNSTABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-api-events.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api-events) |
| [Context API](./context) | OpenTelemetry context API | `opentelemetry-context` | <!--VERSION_STABLE-->1.26.0<!--/VERSION_STABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-context.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context) |
| [Semantic Conventions](./semconv) | Generated code for OpenTelemetry semantic conventions | `opentelemetry-semconv` | <!--VERSION_UNSTABLE-->1.26.0-alpha<!--/VERSION_UNSTABLE--> | [![Javadocs](https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-semconv.svg)](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-semconv) |

6
api/all/src/main/java/io/opentelemetry/api/GlobalOpenTelemetry.java
View File

@ -7,6 +7,7 @@ package io.opentelemetry.api;
import io.opentelemetry.api.internal.ConfigUtil;
import io.opentelemetry.api.internal.GuardedBy;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.api.metrics.MeterBuilder;
import io.opentelemetry.api.metrics.MeterProvider;
@ -281,6 +282,11 @@ public final class GlobalOpenTelemetry {
return delegate.getMeterProvider();
}
@Override
public LoggerProvider getLogsBridge() {
return delegate.getLogsBridge();
}
@Override
public ContextPropagators getPropagators() {
return delegate.getPropagators();

14
api/all/src/main/java/io/opentelemetry/api/OpenTelemetry.java
View File

@ -5,6 +5,7 @@
package io.opentelemetry.api;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.api.metrics.MeterBuilder;
import io.opentelemetry.api.metrics.MeterProvider;
@ -113,6 +114,19 @@ public interface OpenTelemetry {
return getMeterProvider().meterBuilder(instrumentationScopeName);
}
/**
* Returns the {@link LoggerProvider} for bridging logs into OpenTelemetry.
*
* <p>The OpenTelemetry logs bridge API exists to enable bridging logs from other log frameworks
* (e.g. SLF4J, Log4j, JUL, Logback, etc) into OpenTelemetry and is <b>NOT</b> a replacement log
* API.
*
* @since 1.27.0
*/
default LoggerProvider getLogsBridge() {
return LoggerProvider.noop();
}
/** Returns the {@link ContextPropagators} for this {@link OpenTelemetry}. */
ContextPropagators getPropagators();
}

0
api/logs/src/main/java/io/opentelemetry/api/logs/DefaultLogger.java → api/all/src/main/java/io/opentelemetry/api/logs/DefaultLogger.java
View File

0
api/logs/src/main/java/io/opentelemetry/api/logs/DefaultLoggerProvider.java → api/all/src/main/java/io/opentelemetry/api/logs/DefaultLoggerProvider.java
View File

2
api/logs/src/main/java/io/opentelemetry/api/logs/LogRecordBuilder.java → api/all/src/main/java/io/opentelemetry/api/logs/LogRecordBuilder.java
View File

@ -16,6 +16,8 @@ import java.util.concurrent.TimeUnit;
*
* <p>Obtain a {@link Logger#logRecordBuilder()}, add properties using the setters, and emit the log
* record by calling {@link #emit()}.
*
* @since 1.27.0
*/
public interface LogRecordBuilder {

6
api/logs/src/main/java/io/opentelemetry/api/logs/Logger.java → api/all/src/main/java/io/opentelemetry/api/logs/Logger.java
View File

@ -12,6 +12,12 @@ import javax.annotation.concurrent.ThreadSafe;
*
* <p>Obtain a {@link #logRecordBuilder()}, add properties using the setters, and emit it via {@link
* LogRecordBuilder#emit()}.
*
* <p>The OpenTelemetry logs bridge API exists to enable bridging logs from other log frameworks
* (e.g. SLF4J, Log4j, JUL, Logback, etc) into OpenTelemetry and is <b>NOT</b> a replacement log
* API.
*
* @since 1.27.0
*/
@ThreadSafe
public interface Logger {

2
api/logs/src/main/java/io/opentelemetry/api/logs/LoggerBuilder.java → api/all/src/main/java/io/opentelemetry/api/logs/LoggerBuilder.java
View File

@ -11,6 +11,8 @@ package io.opentelemetry.api.logs;
* <p>{@link Logger}s are identified by their scope name, version, and schema URL. These identifying
* fields, along with attributes, combine to form the instrumentation scope, which is attached to
* all log records produced by the {@link Logger}.
*
* @since 1.27.0
*/
public interface LoggerBuilder {

7
api/logs/src/main/java/io/opentelemetry/api/logs/LoggerProvider.java → api/all/src/main/java/io/opentelemetry/api/logs/LoggerProvider.java
View File

@ -11,10 +11,11 @@ import javax.annotation.concurrent.ThreadSafe;
* A registry for creating scoped {@link Logger}s. The name <i>Provider</i> is for consistency with
* other languages and it is <b>NOT</b> loaded using reflection.
*
* <p>The OpenTelemetry logging API exists to enable the creation of log appenders, which bridge
* logs from other log frameworks (e.g. SLF4J, Log4j, JUL, Logback, etc) into OpenTelemetry via
* {@link Logger#logRecordBuilder()}. It is <b>NOT</b> a replacement log framework.
* <p>The OpenTelemetry logs bridge API exists to enable bridging logs from other log frameworks
* (e.g. SLF4J, Log4j, JUL, Logback, etc) into OpenTelemetry and is <b>NOT</b> a replacement log
* API.
*
* @since 1.27.0
* @see Logger
*/
@ThreadSafe

5
api/logs/src/main/java/io/opentelemetry/api/logs/Severity.java → api/all/src/main/java/io/opentelemetry/api/logs/Severity.java
View File

@ -5,6 +5,11 @@
package io.opentelemetry.api.logs;
/**
* Log record severity options.
*
* @since 1.27.0
*/
public enum Severity {
UNDEFINED_SEVERITY_NUMBER(0),
TRACE(1),

17
api/all/src/main/java/io/opentelemetry/api/logs/package-info.java Normal file
View File

@ -0,0 +1,17 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
/**
* API for writing log appenders.
*
* <p>The OpenTelemetry logging API exists to enable the creation of log appenders, which bridge
* logs from other log frameworks (e.g. SLF4J, Log4j, JUL, Logback, etc) into OpenTelemetry via
* {@link io.opentelemetry.api.logs.Logger#logRecordBuilder()}. It is <b>NOT</b> a replacement log
* framework.
*/
@ParametersAreNonnullByDefault
package io.opentelemetry.api.logs;
import javax.annotation.ParametersAreNonnullByDefault;

3
api/all/src/test/java/io/opentelemetry/api/OpenTelemetryTest.java
View File

@ -9,6 +9,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.metrics.MeterProvider;
import io.opentelemetry.api.trace.TracerProvider;
import io.opentelemetry.context.propagation.ContextPropagators;
@ -33,6 +34,7 @@ class OpenTelemetryTest {
assertThat(OpenTelemetry.noop().getTracerProvider()).isSameAs(TracerProvider.noop());
assertThat(OpenTelemetry.noop().getPropagators()).isSameAs(ContextPropagators.noop());
assertThat(OpenTelemetry.noop().getMeterProvider()).isSameAs(MeterProvider.noop());
assertThat(OpenTelemetry.noop().getLogsBridge()).isSameAs(LoggerProvider.noop());
}
@Test
@ -42,6 +44,7 @@ class OpenTelemetryTest {
assertThat(openTelemetry.getTracerProvider()).isSameAs(TracerProvider.noop());
assertThat(openTelemetry.getMeterProvider()).isSameAs(MeterProvider.noop());
assertThat(openTelemetry.getLogsBridge()).isSameAs(LoggerProvider.noop());
assertThat(openTelemetry.getPropagators()).isSameAs(contextPropagators);
}

0
api/logs/src/test/java/io/opentelemetry/api/logs/DefaultLoggerProviderTest.java → api/all/src/test/java/io/opentelemetry/api/logs/DefaultLoggerProviderTest.java
View File

0
api/logs/src/test/java/io/opentelemetry/api/logs/DefaultLoggerTest.java → api/all/src/test/java/io/opentelemetry/api/logs/DefaultLoggerTest.java
View File

13
api/logs/build.gradle.kts
View File

@ -1,13 +0,0 @@
plugins {
id("otel.java-conventions")
id("otel.publish-conventions")
id("otel.animalsniffer-conventions")
}
description = "OpenTelemetry Logs API"
otelJava.moduleName.set("io.opentelemetry.api.logs")
dependencies {
api(project(":api:all"))
}

1
api/logs/gradle.properties
View File

@ -1 +0,0 @@
otel.release=alpha

58
api/logs/src/main/java/io/opentelemetry/api/logs/GlobalLoggerProvider.java
View File

@ -1,58 +0,0 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.api.logs;
import io.opentelemetry.api.GlobalOpenTelemetry;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nullable;
/**
* This class provides a temporary global accessor for {@link LoggerProvider} until the log API is
* marked stable. It will eventually be merged into {@link GlobalOpenTelemetry}.
*/
// We intentionally assign to be used for error reporting.
@SuppressWarnings("StaticAssignmentOfThrowable")
public final class GlobalLoggerProvider {
private static final AtomicReference<LoggerProvider> instance =
new AtomicReference<>(LoggerProvider.noop());
@Nullable private static volatile Throwable setInstanceCaller;
private GlobalLoggerProvider() {}
/** Returns the globally registered {@link LoggerProvider}. */
// instance cannot be set to null
@SuppressWarnings("NullAway")
public static LoggerProvider get() {
return instance.get();
}
/**
* Sets the global {@link LoggerProvider}. Future calls to {@link #get()} will return the provided
* {@link LoggerProvider} instance. This should be called once as early as possible in your
* application initialization logic.
*/
public static void set(LoggerProvider loggerProvider) {
boolean changed = instance.compareAndSet(LoggerProvider.noop(), loggerProvider);
if (!changed && (loggerProvider != LoggerProvider.noop())) {
throw new IllegalStateException(
"GlobalLoggerProvider.set has already been called. GlobalLoggerProvider.set "
+ "must be called only once before any calls to GlobalLoggerProvider.get. "
+ "Previous invocation set to cause of this exception.",
setInstanceCaller);
}
setInstanceCaller = new Throwable();
}
/**
* Unsets the global {@link LoggerProvider}. This is only meant to be used from tests which need
* to reconfigure {@link LoggerProvider}.
*/
public static void resetForTest() {
instance.set(LoggerProvider.noop());
}
}

49
api/logs/src/test/java/io/opentelemetry/api/logs/GlobalLoggerProviderTest.java
View File

@ -1,49 +0,0 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.api.logs;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
class GlobalLoggerProviderTest {
@BeforeAll
static void beforeClass() {
GlobalLoggerProvider.resetForTest();
}
@AfterEach
void after() {
GlobalLoggerProvider.resetForTest();
}
@Test
void setAndGet() {
assertThat(GlobalLoggerProvider.get()).isEqualTo(LoggerProvider.noop());
LoggerProvider loggerProvider =
instrumentationScopeName -> LoggerProvider.noop().loggerBuilder(instrumentationScopeName);
GlobalLoggerProvider.set(loggerProvider);
assertThat(GlobalLoggerProvider.get()).isEqualTo(loggerProvider);
}
@Test
void setThenSet() {
GlobalLoggerProvider.set(
instrumentationScopeName -> LoggerProvider.noop().loggerBuilder(instrumentationScopeName));
assertThatThrownBy(
() ->
GlobalLoggerProvider.set(
instrumentationScopeName ->
LoggerProvider.noop().loggerBuilder(instrumentationScopeName)))
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("GlobalLoggerProvider.set has already been called")
.hasStackTraceContaining("setThenSet");
}
}

68
docs/apidiffs/current_vs_latest/opentelemetry-api.txt
View File

@ -1,2 +1,68 @@
Comparing source compatibility of against
No changes.
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.Logger (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder logRecordBuilder()
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LoggerBuilder (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.Logger build()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LoggerBuilder setInstrumentationVersion(java.lang.String)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LoggerBuilder setSchemaUrl(java.lang.String)
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LoggerProvider (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.Logger get(java.lang.String)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LoggerBuilder loggerBuilder(java.lang.String)
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.api.logs.LoggerProvider noop()
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) void emit()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.LogRecordBuilder setAllAttributes(io.opentelemetry.api.common.Attributes)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setAttribute(io.opentelemetry.api.common.AttributeKey, java.lang.Object)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setBody(java.lang.String)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setContext(io.opentelemetry.context.Context)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setObservedTimestamp(long, java.util.concurrent.TimeUnit)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setObservedTimestamp(java.time.Instant)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setSeverity(io.opentelemetry.api.logs.Severity)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setSeverityText(java.lang.String)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setTimestamp(long, java.util.concurrent.TimeUnit)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.LogRecordBuilder setTimestamp(java.time.Instant)
+++ NEW ENUM: PUBLIC(+) FINAL(+) io.opentelemetry.api.logs.Severity (compatible)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: java.lang.constant.Constable
+++ NEW INTERFACE: java.lang.Comparable
+++ NEW INTERFACE: java.io.Serializable
+++ NEW SUPERCLASS: java.lang.Enum
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity WARN2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity WARN3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity WARN4
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity INFO
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity TRACE2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity DEBUG4
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity DEBUG3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity TRACE4
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity TRACE3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity ERROR
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity FATAL
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity TRACE
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity FATAL2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity FATAL3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity ERROR2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity ERROR3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity ERROR4
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity DEBUG2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity INFO3
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity DEBUG
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity INFO2
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity WARN
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity INFO4
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity UNDEFINED_SEVERITY_NUMBER
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.api.logs.Severity FATAL4
+++ NEW METHOD: PUBLIC(+) int getSeverityNumber()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.api.logs.Severity valueOf(java.lang.String)
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.api.logs.Severity[] values()
*** MODIFIED INTERFACE: PUBLIC ABSTRACT io.opentelemetry.api.OpenTelemetry (not serializable)
=== CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.LoggerProvider getLogsBridge()

124
docs/apidiffs/current_vs_latest/opentelemetry-sdk-logs.txt Normal file
View File

@ -0,0 +1,124 @@
Comparing source compatibility of against
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.data.Body (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) java.lang.String asString()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.data.Body empty()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.data.Body$Type getType()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.data.Body string(java.lang.String)
+++ NEW ENUM: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.sdk.logs.data.Body$Type (compatible)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: java.lang.constant.Constable
+++ NEW INTERFACE: java.lang.Comparable
+++ NEW INTERFACE: java.io.Serializable
+++ NEW SUPERCLASS: java.lang.Enum
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.sdk.logs.data.Body$Type STRING
+++ NEW FIELD: PUBLIC(+) STATIC(+) FINAL(+) io.opentelemetry.sdk.logs.data.Body$Type EMPTY
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.data.Body$Type valueOf(java.lang.String)
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.data.Body$Type[] values()
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.data.LogRecordData (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.common.Attributes getAttributes()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.data.Body getBody()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.common.InstrumentationScopeInfo getInstrumentationScopeInfo()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) long getObservedTimestampEpochNanos()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.resources.Resource getResource()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.logs.Severity getSeverity()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) java.lang.String getSeverityText()
+++ NEW ANNOTATION: javax.annotation.Nullable
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.api.trace.SpanContext getSpanContext()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) long getTimestampEpochNanos()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) int getTotalAttributeCount()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: io.opentelemetry.sdk.logs.LogRecordProcessor
+++ NEW INTERFACE: java.io.Closeable
+++ NEW INTERFACE: java.lang.AutoCloseable
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder builder(io.opentelemetry.sdk.logs.export.LogRecordExporter)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode forceFlush()
+++ NEW METHOD: PUBLIC(+) void onEmit(io.opentelemetry.context.Context, io.opentelemetry.sdk.logs.ReadWriteLogRecord)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown()
+++ NEW METHOD: PUBLIC(+) java.lang.String toString()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor build()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setExporterTimeout(long, java.util.concurrent.TimeUnit)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setExporterTimeout(java.time.Duration)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setMaxExportBatchSize(int)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setMaxQueueSize(int)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setMeterProvider(io.opentelemetry.api.metrics.MeterProvider)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setScheduleDelay(long, java.util.concurrent.TimeUnit)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setScheduleDelay(java.time.Duration)
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.export.LogRecordExporter (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: java.io.Closeable
+++ NEW INTERFACE: java.lang.AutoCloseable
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) void close()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.export.LogRecordExporter composite(io.opentelemetry.sdk.logs.export.LogRecordExporter[])
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.export.LogRecordExporter composite(java.lang.Iterable)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.common.CompletableResultCode export(java.util.Collection)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.common.CompletableResultCode flush()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: io.opentelemetry.sdk.logs.LogRecordProcessor
+++ NEW INTERFACE: java.io.Closeable
+++ NEW INTERFACE: java.lang.AutoCloseable
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.LogRecordProcessor create(io.opentelemetry.sdk.logs.export.LogRecordExporter)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode forceFlush()
+++ NEW METHOD: PUBLIC(+) void onEmit(io.opentelemetry.context.Context, io.opentelemetry.sdk.logs.ReadWriteLogRecord)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown()
+++ NEW METHOD: PUBLIC(+) java.lang.String toString()
+++ NEW CLASS: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.LogLimits (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.LogLimitsBuilder builder()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.LogLimits getDefault()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) int getMaxAttributeValueLength()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) int getMaxNumberOfAttributes()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.LogLimitsBuilder toBuilder()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.LogLimitsBuilder (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.LogLimits build()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.LogLimitsBuilder setMaxAttributeValueLength(int)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.LogLimitsBuilder setMaxNumberOfAttributes(int)
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.LogRecordProcessor (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW INTERFACE: java.io.Closeable
+++ NEW INTERFACE: java.lang.AutoCloseable
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) void close()
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.LogRecordProcessor composite(io.opentelemetry.sdk.logs.LogRecordProcessor[])
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.LogRecordProcessor composite(java.lang.Iterable)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode forceFlush()
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) void onEmit(io.opentelemetry.context.Context, io.opentelemetry.sdk.logs.ReadWriteLogRecord)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown()
+++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.ReadWriteLogRecord (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.ReadWriteLogRecord setAttribute(io.opentelemetry.api.common.AttributeKey, java.lang.Object)
+++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.data.LogRecordData toLogRecordData()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.SdkLoggerProvider (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder builder()
+++ NEW METHOD: PUBLIC(+) void close()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode forceFlush()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.Logger get(java.lang.String)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.LoggerBuilder loggerBuilder(java.lang.String)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown()
+++ NEW METHOD: PUBLIC(+) java.lang.String toString()
+++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder (not serializable)
+++ CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+++ NEW SUPERCLASS: java.lang.Object
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder addLogRecordProcessor(io.opentelemetry.sdk.logs.LogRecordProcessor)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProvider build()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder setClock(io.opentelemetry.sdk.common.Clock)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder setLogLimits(java.util.function.Supplier)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder setResource(io.opentelemetry.sdk.resources.Resource)

4
docs/apidiffs/current_vs_latest/opentelemetry-sdk.txt
View File

@ -1,2 +1,4 @@
Comparing source compatibility of against
No changes.
*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.OpenTelemetrySdk (not serializable)
=== CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.api.logs.LoggerProvider getLogsBridge()

1
integration-tests/otlp/build.gradle.kts
View File

@ -10,6 +10,7 @@ dependencies {
implementation(project(":exporters:otlp:all"))
implementation(project(":exporters:otlp:logs"))
implementation(project(":api:events"))
implementation(project(":semconv"))
compileOnly("com.google.errorprone:error_prone_annotations")

4
sdk-extensions/autoconfigure/build.gradle.kts
View File

@ -8,10 +8,9 @@ otelJava.moduleName.set("io.opentelemetry.sdk.autoconfigure")
dependencies {
api(project(":sdk:all"))
api(project(":sdk:metrics"))
api(project(":sdk:logs"))
api(project(":sdk-extensions:autoconfigure-spi"))
implementation(project(":api:events"))
implementation(project(":semconv"))
annotationProcessor("com.google.auto.value:auto-value")
@ -53,6 +52,7 @@ testing {
}
val testFullConfig by registering(JvmTestSuite::class) {
dependencies {
implementation(project(":api:events"))
implementation(project(":extensions:trace-propagators"))
implementation(project(":exporters:jaeger"))
implementation(project(":exporters:logging"))

2
sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java
View File

@ -9,7 +9,6 @@ import static java.util.Objects.requireNonNull;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.events.GlobalEventEmitterProvider;
import io.opentelemetry.api.logs.GlobalLoggerProvider;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.sdk.OpenTelemetrySdk;
@ -399,7 +398,6 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
if (setResultAsGlobal) {
GlobalOpenTelemetry.set(openTelemetrySdk);
GlobalLoggerProvider.set(openTelemetrySdk.getSdkLoggerProvider());
GlobalEventEmitterProvider.set(
SdkEventEmitterProvider.create(openTelemetrySdk.getSdkLoggerProvider()));
logger.log(

4
sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java
View File

@ -23,7 +23,6 @@ import io.github.netmikey.logunit.api.LogCapturer;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.events.GlobalEventEmitterProvider;
import io.opentelemetry.api.logs.GlobalLoggerProvider;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanId;
import io.opentelemetry.api.trace.TraceId;
@ -145,7 +144,6 @@ class AutoConfiguredOpenTelemetrySdkTest {
@BeforeEach
void resetGlobal() {
GlobalOpenTelemetry.resetForTest();
GlobalLoggerProvider.resetForTest();
GlobalEventEmitterProvider.resetForTest();
builder =
AutoConfiguredOpenTelemetrySdk.builder()
@ -360,7 +358,6 @@ class AutoConfiguredOpenTelemetrySdkTest {
OpenTelemetrySdk openTelemetry = builder.setResultAsGlobal(false).build().getOpenTelemetrySdk();
assertThat(GlobalOpenTelemetry.get()).extracting("delegate").isNotSameAs(openTelemetry);
assertThat(GlobalLoggerProvider.get()).isNotSameAs(openTelemetry.getSdkLoggerProvider());
assertThat(GlobalEventEmitterProvider.get()).isNotSameAs(openTelemetry.getSdkLoggerProvider());
}
@ -369,7 +366,6 @@ class AutoConfiguredOpenTelemetrySdkTest {
OpenTelemetrySdk openTelemetry = builder.setResultAsGlobal(true).build().getOpenTelemetrySdk();
assertThat(GlobalOpenTelemetry.get()).extracting("delegate").isSameAs(openTelemetry);
assertThat(GlobalLoggerProvider.get()).isSameAs(openTelemetry.getSdkLoggerProvider());
assertThat(GlobalEventEmitterProvider.get())
.isInstanceOf(SdkEventEmitterProvider.class)
.extracting("delegateLoggerProvider")

2
sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java
View File

@ -11,7 +11,6 @@ import io.github.netmikey.logunit.api.LogCapturer;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.events.GlobalEventEmitterProvider;
import io.opentelemetry.api.logs.GlobalLoggerProvider;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import java.lang.reflect.Field;
import org.junit.jupiter.api.BeforeEach;
@ -29,7 +28,6 @@ class AutoConfiguredOpenTelemetrySdkTest {
@BeforeEach
void setUp() {
GlobalOpenTelemetry.resetForTest();
GlobalLoggerProvider.resetForTest();
GlobalEventEmitterProvider.resetForTest();
}

2
sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigErrorTest.java
View File

@ -11,7 +11,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import io.github.netmikey.logunit.api.LogCapturer;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.logs.GlobalLoggerProvider;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.internal.testing.slf4j.SuppressLogger;
import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException;
@ -32,7 +31,6 @@ class ConfigErrorTest {
@BeforeEach
void setup() {
GlobalOpenTelemetry.resetForTest();
GlobalLoggerProvider.resetForTest();
}
@Test

5
sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/FullConfigTest.java
View File

@ -20,7 +20,6 @@ import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.events.EventEmitter;
import io.opentelemetry.api.events.GlobalEventEmitterProvider;
import io.opentelemetry.api.logs.GlobalLoggerProvider;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.Severity;
import io.opentelemetry.api.metrics.Meter;
@ -162,7 +161,6 @@ class FullConfigTest {
// Initialize here so we can shutdown when done
GlobalOpenTelemetry.resetForTest();
GlobalLoggerProvider.resetForTest();
GlobalEventEmitterProvider.resetForTest();
openTelemetrySdk = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk();
}
@ -171,7 +169,6 @@ class FullConfigTest {
void afterEach() {
openTelemetrySdk.close();
GlobalOpenTelemetry.resetForTest();
GlobalLoggerProvider.resetForTest();
GlobalEventEmitterProvider.resetForTest();
}
@ -207,7 +204,7 @@ class FullConfigTest {
.add(1, Attributes.builder().put("allowed", "bear").put("not allowed", "dog").build());
meter.counterBuilder("my-other-metric").build().add(1);
Logger logger = GlobalLoggerProvider.get().get("test");
Logger logger = GlobalOpenTelemetry.get().getLogsBridge().get("test");
logger.logRecordBuilder().setBody("debug log message").setSeverity(Severity.DEBUG).emit();
logger.logRecordBuilder().setBody("info log message").setSeverity(Severity.INFO).emit();

5
sdk/all/build.gradle.kts
View File

@ -15,10 +15,7 @@ dependencies {
api(project(":sdk:common"))
api(project(":sdk:trace"))
api(project(":sdk:metrics"))
// implementation dependency to require users to add the artifact directly to their build to use
// SdkLoggerProvider.
implementation(project(":sdk:logs"))
api(project(":sdk:logs"))
annotationProcessor("com.google.auto.value:auto-value")

44
sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdk.java
View File

@ -6,6 +6,8 @@
package io.opentelemetry.sdk;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.logs.LoggerBuilder;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.metrics.MeterBuilder;
import io.opentelemetry.api.metrics.MeterProvider;
import io.opentelemetry.api.trace.Tracer;
@ -33,7 +35,7 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
private final AtomicBoolean isShutdown = new AtomicBoolean(false);
private final ObfuscatedTracerProvider tracerProvider;
private final ObfuscatedMeterProvider meterProvider;
private final SdkLoggerProvider loggerProvider;
private final ObfuscatedLoggerProvider loggerProvider;
private final ContextPropagators propagators;
OpenTelemetrySdk(
@ -43,7 +45,7 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
ContextPropagators propagators) {
this.tracerProvider = new ObfuscatedTracerProvider(tracerProvider);
this.meterProvider = new ObfuscatedMeterProvider(meterProvider);
this.loggerProvider = loggerProvider;
this.loggerProvider = new ObfuscatedLoggerProvider(loggerProvider);
this.propagators = propagators;
}
@ -75,13 +77,18 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
return meterProvider.unobfuscate();
}
@Override
public LoggerProvider getLogsBridge() {
return loggerProvider;
}
/**
* Returns the {@link SdkLoggerProvider} for this {@link OpenTelemetrySdk}.
*
* @since 1.19.0
*/
public SdkLoggerProvider getSdkLoggerProvider() {
return loggerProvider;
return loggerProvider.unobfuscate();
}
@Override
@ -103,7 +110,7 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
List<CompletableResultCode> results = new ArrayList<>();
results.add(tracerProvider.unobfuscate().shutdown());
results.add(meterProvider.unobfuscate().shutdown());
results.add(loggerProvider.shutdown());
results.add(loggerProvider.unobfuscate().shutdown());
return CompletableResultCode.ofAll(results);
}
@ -120,7 +127,7 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
+ ", meterProvider="
+ meterProvider.unobfuscate()
+ ", loggerProvider="
+ loggerProvider
+ loggerProvider.unobfuscate()
+ ", propagators="
+ propagators
+ "}";
@ -189,4 +196,31 @@ public final class OpenTelemetrySdk implements OpenTelemetry, Closeable {
return delegate;
}
}
/**
* This class allows the SDK to unobfuscate an obfuscated static global provider.
*
* <p>Static global providers are obfuscated when they are returned from the API to prevent users
* from casting them to their SDK specific implementation. For example, we do not want users to
* use patterns like {@code (SdkMeterProvider) openTelemetry.getMeterProvider()}.
*/
@ThreadSafe
// Visible for testing
static class ObfuscatedLoggerProvider implements LoggerProvider {
private final SdkLoggerProvider delegate;
ObfuscatedLoggerProvider(SdkLoggerProvider delegate) {
this.delegate = delegate;
}
@Override
public LoggerBuilder loggerBuilder(String instrumentationScopeName) {
return delegate.loggerBuilder(instrumentationScopeName);
}
public SdkLoggerProvider unobfuscate() {
return delegate;
}
}
}

5
sdk/logs/build.gradle.kts
View File

@ -10,10 +10,11 @@ description = "OpenTelemetry Log SDK"
otelJava.moduleName.set("io.opentelemetry.sdk.logs")
dependencies {
api(project(":api:logs"))
api(project(":api:events"))
api(project(":api:all"))
api(project(":sdk:common"))
implementation(project(":api:events"))
testImplementation(project(":sdk:logs-testing"))
testImplementation("org.awaitility:awaitility")

1
sdk/logs/gradle.properties
View File

@ -1 +0,0 @@
otel.release=alpha

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogLimits.java
View File

@ -16,6 +16,8 @@ import javax.annotation.concurrent.Immutable;
* <p>Note: To allow dynamic updates of {@link LogLimits} you should register a {@link
* java.util.function.Supplier} with {@link SdkLoggerProviderBuilder#setLogLimits(Supplier)} which
* supplies dynamic configs when queried.
*
* @since 1.27.0
*/
@AutoValue
@Immutable

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogLimitsBuilder.java
View File

@ -8,7 +8,11 @@ package io.opentelemetry.sdk.logs;
import io.opentelemetry.api.internal.Utils;
import io.opentelemetry.sdk.logs.data.LogRecordData;
/** Builder for {@link LogLimits}. */
/**
* Builder for {@link LogLimits}.
*
* @since 1.27.0
*/
public final class LogLimitsBuilder {
private static final int DEFAULT_LOG_MAX_NUM_ATTRIBUTES = 128;

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/ReadWriteLogRecord.java
View File

@ -8,7 +8,11 @@ package io.opentelemetry.sdk.logs;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.sdk.logs.data.LogRecordData;
/** A log record that can be read from and written to. */
/**
* A log record that can be read from and written to.
*
* @since 1.27.0
*/
public interface ReadWriteLogRecord {
/**

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProvider.java
View File

@ -20,7 +20,11 @@ import java.util.function.Supplier;
import java.util.logging.Level;
import javax.annotation.Nullable;
/** SDK implementation for {@link LoggerProvider}. */
/**
* SDK implementation for {@link LoggerProvider}.
*
* @since 1.27.0
*/
public final class SdkLoggerProvider implements LoggerProvider, Closeable {
static final String DEFAULT_LOGGER_NAME = "unknown";

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProviderBuilder.java
View File

@ -17,7 +17,11 @@ import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
/** Builder class for {@link SdkLoggerProvider} instances. */
/**
* Builder class for {@link SdkLoggerProvider} instances.
*
* @since 1.27.0
*/
public final class SdkLoggerProviderBuilder {
private final List<LogRecordProcessor> logRecordProcessors = new ArrayList<>();

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/data/Body.java
View File

@ -12,6 +12,8 @@ import javax.annotation.concurrent.Immutable;
* have 1 type of values: {@code String}, represented through {@code Body.Type}. This class will
* likely be extended in the future to include additional body types supported by the OpenTelemetry
* log data model.
*
* @since 1.27.0
*/
@Immutable
public interface Body {

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/data/LogRecordData.java
View File

@ -18,6 +18,8 @@ import javax.annotation.concurrent.Immutable;
* Log definition as described in <a
* href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md">OpenTelemetry
* Log Data Model</a>.
*
* @since 1.27.0
*/
@Immutable
public interface LogRecordData {

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogRecordProcessor.java
View File

@ -36,6 +36,8 @@ import java.util.logging.Logger;
* {@code maxQueueSize} maximum size, if queue is full logs are dropped). Logs are exported either
* when there are {@code maxExportBatchSize} pending logs or {@code scheduleDelayNanos} has passed
* since the last export finished.
*
* @since 1.27.0
*/
public final class BatchLogRecordProcessor implements LogRecordProcessor {

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogRecordProcessorBuilder.java
View File

@ -12,7 +12,11 @@ import io.opentelemetry.api.metrics.MeterProvider;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
/** Builder class for {@link BatchLogRecordProcessor}. */
/**
* Builder class for {@link BatchLogRecordProcessor}.
*
* @since 1.27.0
*/
public final class BatchLogRecordProcessorBuilder {
// Visible for testing

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogRecordExporter.java
View File

@ -19,6 +19,8 @@ import java.util.concurrent.TimeUnit;
/**
* An exporter is responsible for taking a collection of {@link LogRecordData}s and transmitting
* them to their ultimate destination.
*
* @since 1.27.0
*/
public interface LogRecordExporter extends Closeable {

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/SimpleLogRecordProcessor.java
View File

@ -29,6 +29,8 @@ import java.util.logging.Logger;
* so unless you know what you're doing, strongly consider using {@link BatchLogRecordProcessor}
* instead, including in special environments such as serverless runtimes. {@link
* SimpleLogRecordProcessor} is generally meant to for testing only.
*
* @since 1.27.0
*/
public final class SimpleLogRecordProcessor implements LogRecordProcessor {

5
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkEventEmitterProviderTest.java → sdk/logs/src/test/java/io/opentelemetry/sdk/logs/internal/SdkEventEmitterProviderTest.java
View File

@ -3,7 +3,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.logs;
package io.opentelemetry.sdk.logs.internal;
import static io.opentelemetry.sdk.testing.assertj.LogAssertions.assertThat;
import static org.mockito.Mockito.mock;
@ -12,7 +12,8 @@ import static org.mockito.Mockito.when;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.sdk.common.Clock;
import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
import io.opentelemetry.sdk.logs.internal.SdkEventEmitterProvider;
import io.opentelemetry.sdk.logs.ReadWriteLogRecord;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.resources.Resource;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.Test;

1
settings.gradle.kts
View File

@ -23,7 +23,6 @@ rootProject.name = "opentelemetry-java"
include(":all")
include(":api:all")
include(":api:events")
include(":api:logs")
include(":semconv")
include(":bom")
include(":bom-alpha")