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

Remove log record timestamp default (#5374)

This commit is contained in:
jack-berg 2023-04-14 15:30:29 -05:00 committed by GitHub
parent 8f6f9e712d
commit cbbba71b78
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 41 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java
View File

@ -71,11 +71,11 @@ import io.opentelemetry.sdk.trace.export.SpanExporter;
import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;
import java.io.UncheckedIOException;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
@ -530,11 +530,11 @@ abstract class OtlpExporterIntegrationTest {
try (Scope unused = Span.wrap(spanContext).makeCurrent()) {
logger
.logRecordBuilder()
.setTimestamp(100, TimeUnit.NANOSECONDS)
.setBody("log body")
.setAllAttributes(Attributes.builder().put("key", "value").build())
.setSeverity(Severity.DEBUG)
.setSeverityText("DEBUG")
.setTimestamp(Instant.now())
.setContext(Context.current())
.emit();
eventEmitter.emit("event-name", Attributes.builder().put("key", "value").build());
@ -582,7 +582,7 @@ abstract class OtlpExporterIntegrationTest {
.isEqualTo(spanContext.getSpanId());
assertThat(TraceFlags.fromByte((byte) protoLog1.getFlags()))
.isEqualTo(spanContext.getTraceFlags());
assertThat(protoLog1.getTimeUnixNano()).isGreaterThan(0);
assertThat(protoLog1.getTimeUnixNano()).isEqualTo(100);
// LogRecord via EventEmitter.emit(String, Attributes)
io.opentelemetry.proto.logs.v1.LogRecord protoLog2 = ilLogs.getLogRecords(1);

28
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkEventEmitterProvider.java
View File

@ -13,6 +13,8 @@ import io.opentelemetry.api.events.EventEmitterProvider;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.LoggerBuilder;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.sdk.common.Clock;
import java.util.concurrent.TimeUnit;
/**
* SDK implementation for {@link EventEmitterProvider}.
@ -25,16 +27,25 @@ public final class SdkEventEmitterProvider implements EventEmitterProvider {
private static final String DEFAULT_EVENT_DOMAIN = "unknown";
private final LoggerProvider delegateLoggerProvider;
private final Clock clock;
private SdkEventEmitterProvider(LoggerProvider delegateLoggerProvider) {
private SdkEventEmitterProvider(LoggerProvider delegateLoggerProvider, Clock clock) {
this.delegateLoggerProvider = delegateLoggerProvider;
this.clock = clock;
}
/**
* Create a {@link SdkEventEmitterProvider} which delegates to the {@code delegateLoggerProvider}.
*/
public static SdkEventEmitterProvider create(LoggerProvider delegateLoggerProvider) {
return new SdkEventEmitterProvider(delegateLoggerProvider);
return new SdkEventEmitterProvider(delegateLoggerProvider, Clock.getDefault());
}
/**
* Create a {@link SdkEventEmitterProvider} which delegates to the {@code delegateLoggerProvider}.
*/
public static SdkEventEmitterProvider create(LoggerProvider delegateLoggerProvider, Clock clock) {
return new SdkEventEmitterProvider(delegateLoggerProvider, clock);
}
@Override
@ -47,15 +58,17 @@ public final class SdkEventEmitterProvider implements EventEmitterProvider {
@Override
public EventEmitterBuilder eventEmitterBuilder(String instrumentationScopeName) {
return new SdkEventEmitterBuilder(
delegateLoggerProvider.loggerBuilder(instrumentationScopeName));
clock, delegateLoggerProvider.loggerBuilder(instrumentationScopeName));
}
private static class SdkEventEmitterBuilder implements EventEmitterBuilder {
private final Clock clock;
private final LoggerBuilder delegateLoggerBuilder;
private String eventDomain = DEFAULT_EVENT_DOMAIN;
private SdkEventEmitterBuilder(LoggerBuilder delegateLoggerBuilder) {
private SdkEventEmitterBuilder(Clock clock, LoggerBuilder delegateLoggerBuilder) {
this.clock = clock;
this.delegateLoggerBuilder = delegateLoggerBuilder;
}
@ -79,7 +92,7 @@ public final class SdkEventEmitterProvider implements EventEmitterProvider {
@Override
public EventEmitter build() {
return new SdkEventEmitter(delegateLoggerBuilder.build(), eventDomain);
return new SdkEventEmitter(clock, delegateLoggerBuilder.build(), eventDomain);
}
}
@ -88,10 +101,12 @@ public final class SdkEventEmitterProvider implements EventEmitterProvider {
private static final AttributeKey<String> EVENT_DOMAIN = AttributeKey.stringKey("event.domain");
private static final AttributeKey<String> EVENT_NAME = AttributeKey.stringKey("event.name");
private final Clock clock;
private final Logger delegateLogger;
private final String eventDomain;
private SdkEventEmitter(Logger delegateLogger, String eventDomain) {
private SdkEventEmitter(Clock clock, Logger delegateLogger, String eventDomain) {
this.clock = clock;
this.delegateLogger = delegateLogger;
this.eventDomain = eventDomain;
}
@ -100,6 +115,7 @@ public final class SdkEventEmitterProvider implements EventEmitterProvider {
public void emit(String eventName, Attributes attributes) {
delegateLogger
.logRecordBuilder()
.setTimestamp(clock.now(), TimeUnit.NANOSECONDS)
.setAllAttributes(attributes)
.setAttribute(EVENT_DOMAIN, eventDomain)
.setAttribute(EVENT_NAME, eventName)

4
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java
View File

@ -103,9 +103,7 @@ final class SdkLogRecordBuilder implements LogRecordBuilder {
loggerSharedState.getLogLimits(),
loggerSharedState.getResource(),
instrumentationScopeInfo,
this.timestampEpochNanos == 0
? this.loggerSharedState.getClock().now()
: this.timestampEpochNanos,
this.timestampEpochNanos,
Span.fromContext(context).getSpanContext(),
severity,
severityText,

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

@ -72,11 +72,7 @@ public final class SdkLoggerProviderBuilder {
}
/**
* Assign a {@link Clock}. The {@link Clock} may be used to determine "now" in the event that the
* epoch millis are not set directly.
*
* <p>The {@code clock} must be thread-safe and return immediately (no remote calls, as contention
* free as possible).
* Assign a {@link Clock}.
*
* @param clock The clock to use for all temporal needs.
* @return this

13
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkEventEmitterProviderTest.java
View File

@ -6,8 +6,11 @@
package io.opentelemetry.sdk.logs;
import static io.opentelemetry.sdk.testing.assertj.LogAssertions.assertThat;
import static org.mockito.Mockito.mock;
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.resources.Resource;
import java.util.concurrent.atomic.AtomicReference;
@ -18,16 +21,20 @@ class SdkEventEmitterProviderTest {
private static final Resource RESOURCE =
Resource.builder().put("resource-key", "resource-value").build();
private final Clock clock = mock(Clock.class);
private final AtomicReference<ReadWriteLogRecord> seenLog = new AtomicReference<>();
private final SdkEventEmitterProvider eventEmitterProvider =
SdkEventEmitterProvider.create(
SdkLoggerProvider.builder()
.setResource(RESOURCE)
.addLogRecordProcessor((context, logRecord) -> seenLog.set(logRecord))
.build());
.build(),
clock);
@Test
void emit_WithDomain() {
when(clock.now()).thenReturn(10L);
eventEmitterProvider
.eventEmitterBuilder("test-scope")
.setEventDomain("event-domain")
@ -45,6 +52,7 @@ class SdkEventEmitterProviderTest {
assertThat(seenLog.get().toLogRecordData())
.hasResource(RESOURCE)
.hasInstrumentationScope(InstrumentationScopeInfo.create("test-scope"))
.hasTimestamp(10L)
.hasAttributes(
Attributes.builder()
.put("key1", "value1")
@ -55,6 +63,8 @@ class SdkEventEmitterProviderTest {
@Test
void emit_NoDomain() {
when(clock.now()).thenReturn(10L);
eventEmitterProvider
.eventEmitterBuilder("test-scope")
.build()
@ -71,6 +81,7 @@ class SdkEventEmitterProviderTest {
assertThat(seenLog.get().toLogRecordData())
.hasResource(RESOURCE)
.hasInstrumentationScope(InstrumentationScopeInfo.create("test-scope"))
.hasTimestamp(10L)
.hasAttributes(
Attributes.builder()
.put("key1", "value1")

9
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java
View File

@ -6,7 +6,6 @@
package io.opentelemetry.sdk.logs;
import static io.opentelemetry.sdk.testing.assertj.LogAssertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import io.opentelemetry.api.common.AttributeKey;
@ -17,7 +16,6 @@ import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.api.trace.TraceFlags;
import io.opentelemetry.api.trace.TraceState;
import io.opentelemetry.context.Context;
import io.opentelemetry.sdk.common.Clock;
import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
import io.opentelemetry.sdk.logs.data.Body;
import io.opentelemetry.sdk.resources.Resource;
@ -50,7 +48,6 @@ class SdkLogRecordBuilderTest {
when(loggerSharedState.getLogRecordProcessor())
.thenReturn((context, logRecord) -> emittedLog.set(logRecord));
when(loggerSharedState.getResource()).thenReturn(RESOURCE);
when(loggerSharedState.getClock()).thenReturn(Clock.getDefault());
builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO);
}
@ -92,17 +89,13 @@ class SdkLogRecordBuilderTest {
@Test
void emit_NoFields() {
Clock clock = mock(Clock.class);
when(clock.now()).thenReturn(10L);
when(loggerSharedState.getClock()).thenReturn(clock);
builder.emit();
assertThat(emittedLog.get().toLogRecordData())
.hasResource(RESOURCE)
.hasInstrumentationScope(SCOPE_INFO)
.hasBody(Body.empty().asString())
.hasTimestamp(10L)
.hasTimestamp(0L)
.hasAttributes(Attributes.empty())
.hasSpanContext(SpanContext.getInvalid())
.hasSeverity(Severity.UNDEFINED_SEVERITY_NUMBER);

19
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLoggerProviderTest.java
View File

@ -30,8 +30,6 @@ import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
import io.opentelemetry.sdk.logs.data.LogRecordData;
import io.opentelemetry.sdk.resources.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
@ -333,23 +331,6 @@ class SdkLoggerProviderTest {
verify(logRecordProcessor).shutdown();
}
@Test
void canSetClock() {
long now = TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
Clock clock = mock(Clock.class);
when(clock.now()).thenReturn(now);
List<ReadWriteLogRecord> seenLogs = new ArrayList<>();
logRecordProcessor = (context, logRecord) -> seenLogs.add(logRecord);
sdkLoggerProvider =
SdkLoggerProvider.builder()
.setClock(clock)
.addLogRecordProcessor(logRecordProcessor)
.build();
sdkLoggerProvider.loggerBuilder(null).build().logRecordBuilder().emit();
assertThat(seenLogs.size()).isEqualTo(1);
assertThat(seenLogs.get(0).toLogRecordData().getTimestampEpochNanos()).isEqualTo(now);
}
@Test
void toString_Valid() {
when(logRecordProcessor.toString()).thenReturn("MockLogRecordProcessor");

3
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLoggerTest.java
View File

@ -40,7 +40,6 @@ class SdkLoggerTest {
AtomicReference<ReadWriteLogRecord> seenLog = new AtomicReference<>();
LogRecordProcessor logRecordProcessor = (context, logRecord) -> seenLog.set(logRecord);
Clock clock = mock(Clock.class);
when(clock.now()).thenReturn(5L);
when(state.getResource()).thenReturn(Resource.getDefault());
when(state.getLogRecordProcessor()).thenReturn(logRecordProcessor);
@ -52,7 +51,7 @@ class SdkLoggerTest {
// Have to test through the builder
logRecordBuilder.emit();
assertThat(seenLog.get().toLogRecordData()).hasBody("foo").hasTimestamp(5);
assertThat(seenLog.get().toLogRecordData()).hasBody("foo").hasTimestamp(0);
}
@Test