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

otel tracing: add binary format, grpcTraceBinContextPropagator (#11409) 

* otel tracing: add binary format, grpcTraceBinContextPropagator

* exception handling, use api base64 encoder omit padding
remove binary format abstract class in favor of binary marshaller
This commit is contained in:
yifeizhuang 2024-08-12 11:16:54 -07:00 committed by GitHub
parent d1dcfb0451
commit 043ba556b8
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 943 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
opentelemetry/src/main/java/io/grpc/opentelemetry/BinaryFormat.java Normal file
View File

@ -0,0 +1,143 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static com.google.common.base.Preconditions.checkNotNull;
import io.grpc.Metadata;
import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.api.trace.SpanId;
import io.opentelemetry.api.trace.TraceFlags;
import io.opentelemetry.api.trace.TraceId;
import io.opentelemetry.api.trace.TraceState;
import java.util.Arrays;
/**
* Binary encoded {@link SpanContext} for context propagation. This is adapted from OpenCensus
* binary format.
*
* <p>BinaryFormat format:
*
* <ul>
* <li>Binary value: &lt;version_id&gt;&lt;version_format&gt;
* <li>version_id: 1-byte representing the version id.
* <li>For version_id = 0:
* <ul>
* <li>version_format: &lt;field&gt;&lt;field&gt;
* <li>field_format: &lt;field_id&gt;&lt;field_format&gt;
* <li>Fields:
* <ul>
* <li>TraceId: (field_id = 0, len = 16, default = &#34;0000000000000000&#34;) -
* 16-byte array representing the trace_id.
* <li>SpanId: (field_id = 1, len = 8, default = &#34;00000000&#34;) - 8-byte array
* representing the span_id.
* <li>TraceFlags: (field_id = 2, len = 1, default = &#34;0&#34;) - 1-byte array
* representing the trace_flags.
* </ul>
* <li>Fields MUST be encoded using the field id order (smaller to higher).
* <li>Valid value example:
* <ul>
* <li>{0, 0, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1, 97,
* 98, 99, 100, 101, 102, 103, 104, 2, 1}
* <li>version_id = 0;
* <li>trace_id = {64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79}
* <li>span_id = {97, 98, 99, 100, 101, 102, 103, 104};
* <li>trace_flags = {1};
* </ul>
* </ul>
* </ul>
*/
final class BinaryFormat implements Metadata.BinaryMarshaller<SpanContext> {
private static final byte VERSION_ID = 0;
private static final int VERSION_ID_OFFSET = 0;
private static final byte ID_SIZE = 1;
private static final byte TRACE_ID_FIELD_ID = 0;
private static final int TRACE_ID_FIELD_ID_OFFSET = VERSION_ID_OFFSET + ID_SIZE;
private static final int TRACE_ID_OFFSET = TRACE_ID_FIELD_ID_OFFSET + ID_SIZE;
private static final int TRACE_ID_SIZE = TraceId.getLength() / 2;
private static final byte SPAN_ID_FIELD_ID = 1;
private static final int SPAN_ID_FIELD_ID_OFFSET = TRACE_ID_OFFSET + TRACE_ID_SIZE;
private static final int SPAN_ID_OFFSET = SPAN_ID_FIELD_ID_OFFSET + ID_SIZE;
private static final int SPAN_ID_SIZE = SpanId.getLength() / 2;
private static final byte TRACE_FLAG_FIELD_ID = 2;
private static final int TRACE_FLAG_FIELD_ID_OFFSET = SPAN_ID_OFFSET + SPAN_ID_SIZE;
private static final int TRACE_FLAG_OFFSET = TRACE_FLAG_FIELD_ID_OFFSET + ID_SIZE;
private static final int REQUIRED_FORMAT_LENGTH = 3 * ID_SIZE + TRACE_ID_SIZE + SPAN_ID_SIZE;
private static final int TRACE_FLAG_SIZE = TraceFlags.getLength() / 2;
private static final int ALL_FORMAT_LENGTH = REQUIRED_FORMAT_LENGTH + ID_SIZE + TRACE_FLAG_SIZE;
private static final BinaryFormat INSTANCE = new BinaryFormat();
public static BinaryFormat getInstance() {
return INSTANCE;
}
@Override
public byte[] toBytes(SpanContext spanContext) {
checkNotNull(spanContext, "spanContext");
byte[] bytes = new byte[ALL_FORMAT_LENGTH];
bytes[VERSION_ID_OFFSET] = VERSION_ID;
bytes[TRACE_ID_FIELD_ID_OFFSET] = TRACE_ID_FIELD_ID;
System.arraycopy(spanContext.getTraceIdBytes(), 0, bytes, TRACE_ID_OFFSET, TRACE_ID_SIZE);
bytes[SPAN_ID_FIELD_ID_OFFSET] = SPAN_ID_FIELD_ID;
System.arraycopy(spanContext.getSpanIdBytes(), 0, bytes, SPAN_ID_OFFSET, SPAN_ID_SIZE);
bytes[TRACE_FLAG_FIELD_ID_OFFSET] = TRACE_FLAG_FIELD_ID;
bytes[TRACE_FLAG_OFFSET] = spanContext.getTraceFlags().asByte();
return bytes;
}
@Override
public SpanContext parseBytes(byte[] serialized) {
checkNotNull(serialized, "bytes");
if (serialized.length == 0 || serialized[0] != VERSION_ID) {
throw new IllegalArgumentException("Unsupported version.");
}
if (serialized.length < REQUIRED_FORMAT_LENGTH) {
throw new IllegalArgumentException("Invalid input: truncated");
}
String traceId;
String spanId;
TraceFlags traceFlags = TraceFlags.getDefault();
int pos = 1;
if (serialized[pos] == TRACE_ID_FIELD_ID) {
traceId = TraceId.fromBytes(
Arrays.copyOfRange(serialized, pos + ID_SIZE, pos + ID_SIZE + TRACE_ID_SIZE));
pos += ID_SIZE + TRACE_ID_SIZE;
} else {
throw new IllegalArgumentException("Invalid input: expected trace ID at offset " + pos);
}
if (serialized[pos] == SPAN_ID_FIELD_ID) {
spanId = SpanId.fromBytes(
Arrays.copyOfRange(serialized, pos + ID_SIZE, pos + ID_SIZE + SPAN_ID_SIZE));
pos += ID_SIZE + SPAN_ID_SIZE;
} else {
throw new IllegalArgumentException("Invalid input: expected span ID at offset " + pos);
}
if (serialized.length > pos && serialized[pos] == TRACE_FLAG_FIELD_ID) {
if (serialized.length < ALL_FORMAT_LENGTH) {
throw new IllegalArgumentException("Invalid input: truncated");
}
traceFlags = TraceFlags.fromByte(serialized[pos + ID_SIZE]);
}
return SpanContext.create(traceId, spanId, traceFlags, TraceState.getDefault());
}
}

147
opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagator.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static com.google.common.base.Preconditions.checkNotNull;
import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.io.BaseEncoding;
import io.grpc.ExperimentalApi;
import io.grpc.Metadata;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapGetter;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.util.Collection;
import java.util.Collections;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
/**
* A {@link TextMapPropagator} for transmitting "grpc-trace-bin" span context.
*
* <p>This propagator can transmit the "grpc-trace-bin" context in either binary or Base64-encoded
* text format, depending on the capabilities of the provided {@link TextMapGetter} and
* {@link TextMapSetter}.
*
* <p>If the {@code TextMapGetter} and {@code TextMapSetter} only support text format, Base64
* encoding and decoding will be used when communicating with the carrier API. But gRPC uses
* it with gRPC's metadata-based getter/setter, and the propagator can directly transmit the binary
* header, avoiding the need for Base64 encoding.
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/11400")
public final class GrpcTraceBinContextPropagator implements TextMapPropagator {
private static final Logger log = Logger.getLogger(GrpcTraceBinContextPropagator.class.getName());
public static final String GRPC_TRACE_BIN_HEADER = "grpc-trace-bin";
private final Metadata.BinaryMarshaller<SpanContext> binaryFormat;
private static final GrpcTraceBinContextPropagator INSTANCE =
new GrpcTraceBinContextPropagator(BinaryFormat.getInstance());
public static GrpcTraceBinContextPropagator defaultInstance() {
return INSTANCE;
}
@VisibleForTesting
GrpcTraceBinContextPropagator(Metadata.BinaryMarshaller<SpanContext> binaryFormat) {
this.binaryFormat = checkNotNull(binaryFormat, "binaryFormat");
}
@Override
public Collection<String> fields() {
return Collections.singleton(GRPC_TRACE_BIN_HEADER);
}
@Override
public <C> void inject(Context context, @Nullable C carrier, TextMapSetter<C> setter) {
if (context == null || setter == null) {
return;
}
SpanContext spanContext = Span.fromContext(context).getSpanContext();
if (!spanContext.isValid()) {
return;
}
try {
byte[] b = binaryFormat.toBytes(spanContext);
if (setter instanceof MetadataSetter) {
((MetadataSetter) setter).set((Metadata) carrier, GRPC_TRACE_BIN_HEADER, b);
} else {
setter.set(carrier, GRPC_TRACE_BIN_HEADER, BASE64_ENCODING_OMIT_PADDING.encode(b));
}
} catch (Exception e) {
log.log(Level.FINE, "Set grpc-trace-bin spanContext failed", e);
}
}
@Override
public <C> Context extract(Context context, @Nullable C carrier, TextMapGetter<C> getter) {
if (context == null) {
return Context.root();
}
if (getter == null) {
return context;
}
byte[] b;
if (getter instanceof MetadataGetter) {
try {
b = ((MetadataGetter) getter).getBinary((Metadata) carrier, GRPC_TRACE_BIN_HEADER);
if (b == null) {
log.log(Level.FINE, "No grpc-trace-bin present in carrier");
return context;
}
} catch (Exception e) {
log.log(Level.FINE, "Get 'grpc-trace-bin' from MetadataGetter failed", e);
return context;
}
} else {
String value;
try {
value = getter.get(carrier, GRPC_TRACE_BIN_HEADER);
if (value == null) {
log.log(Level.FINE, "No grpc-trace-bin present in carrier");
return context;
}
} catch (Exception e) {
log.log(Level.FINE, "Get 'grpc-trace-bin' from getter failed", e);
return context;
}
try {
b = BaseEncoding.base64().decode(value);
} catch (Exception e) {
log.log(Level.FINE, "Base64-decode spanContext bytes failed", e);
return context;
}
}
SpanContext spanContext;
try {
spanContext = binaryFormat.parseBytes(b);
} catch (Exception e) {
log.log(Level.FINE, "Failed to parse tracing header", e);
return context;
}
if (!spanContext.isValid()) {
return context;
}
return context.with(Span.wrap(spanContext));
}
}

87
opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataGetter.java Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
import io.grpc.Metadata;
import io.opentelemetry.context.propagation.TextMapGetter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
/**
* A TextMapGetter that reads value from gRPC {@link Metadata}. Supports both text and binary
* headers. Supporting binary header is an optimization path for GrpcTraceBinContextPropagator
* to work around the lack of binary propagator API and thus avoid
* base64 (de)encoding when passing data between propagator API interfaces.
*/
final class MetadataGetter implements TextMapGetter<Metadata> {
private static final Logger logger = Logger.getLogger(MetadataGetter.class.getName());
private static final MetadataGetter INSTANCE = new MetadataGetter();
public static MetadataGetter getInstance() {
return INSTANCE;
}
@Override
public Iterable<String> keys(Metadata carrier) {
return carrier.keys();
}
@Nullable
@Override
public String get(@Nullable Metadata carrier, String key) {
if (carrier == null) {
logger.log(Level.FINE, "Carrier is null, getting no data");
return null;
}
try {
if (key.equals("grpc-trace-bin")) {
byte[] value = carrier.get(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
if (value == null) {
return null;
}
return BASE64_ENCODING_OMIT_PADDING.encode(value);
} else {
return carrier.get(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER));
}
} catch (Exception e) {
logger.log(Level.FINE, String.format("Failed to get metadata key %s", key), e);
return null;
}
}
@Nullable
public byte[] getBinary(@Nullable Metadata carrier, String key) {
if (carrier == null) {
logger.log(Level.FINE, "Carrier is null, getting no data");
return null;
}
if (!key.equals("grpc-trace-bin")) {
logger.log(Level.FINE, "Only support 'grpc-trace-bin' binary header. Get no data");
return null;
}
try {
return carrier.get(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
} catch (Exception e) {
logger.log(Level.FINE, String.format("Failed to get metadata key %s", key), e);
return null;
}
}
}

74
opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataSetter.java Normal file
View File

@ -0,0 +1,74 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import com.google.common.io.BaseEncoding;
import io.grpc.Metadata;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
/**
* A {@link TextMapSetter} that sets value to gRPC {@link Metadata}. Supports both text and binary
* headers. Supporting binary header is an optimization path for GrpcTraceBinContextPropagator
* to work around the lack of binary propagator API and thus avoid
* base64 (de)encoding when passing data between propagator API interfaces.
*/
final class MetadataSetter implements TextMapSetter<Metadata> {
private static final Logger logger = Logger.getLogger(MetadataSetter.class.getName());
private static final MetadataSetter INSTANCE = new MetadataSetter();
public static MetadataSetter getInstance() {
return INSTANCE;
}
@Override
public void set(@Nullable Metadata carrier, String key, String value) {
if (carrier == null) {
logger.log(Level.FINE, "Carrier is null, setting no data");
return;
}
try {
if (key.equals("grpc-trace-bin")) {
carrier.put(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER),
BaseEncoding.base64().decode(value));
} else {
carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
}
} catch (Exception e) {
logger.log(Level.INFO, String.format("Failed to set metadata, key=%s", key), e);
}
}
void set(@Nullable Metadata carrier, String key, byte[] value) {
if (carrier == null) {
logger.log(Level.FINE, "Carrier is null, setting no data");
return;
}
if (!key.equals("grpc-trace-bin")) {
logger.log(Level.INFO, "Only support 'grpc-trace-bin' binary header. Set no data");
return;
}
try {
carrier.put(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER), value);
} catch (Exception e) {
logger.log(Level.INFO, String.format("Failed to set metadata key=%s", key), e);
}
}
}

313
opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagatorTest.java Normal file
View File

@ -0,0 +1,313 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static com.google.common.truth.Truth.assertThat;
import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableMap;
import io.grpc.Metadata;
import io.opentelemetry.api.trace.Span;
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.context.propagation.TextMapGetter;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nullable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class GrpcTraceBinContextPropagatorTest {
private static final String TRACE_ID_BASE16 = "e384981d65129fa3e384981d65129fa3";
private static final String SPAN_ID_BASE16 = "e384981d65129fa3";
private static final String TRACE_HEADER_SAMPLED =
"0000" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0201";
private static final String TRACE_HEADER_NOT_SAMPLED =
"0000" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0200";
private final String goldenHeaderEncodedSampled = encode(TRACE_HEADER_SAMPLED);
private final String goldenHeaderEncodedNotSampled = encode(TRACE_HEADER_NOT_SAMPLED);
private static final TextMapSetter<Map<String, String>> setter = Map::put;
private static final TextMapGetter<Map<String, String>> getter =
new TextMapGetter<Map<String, String>>() {
@Override
public Iterable<String> keys(Map<String, String> carrier) {
return carrier.keySet();
}
@Nullable
@Override
public String get(Map<String, String> carrier, String key) {
return carrier.get(key);
}
};
private final GrpcTraceBinContextPropagator grpcTraceBinContextPropagator =
GrpcTraceBinContextPropagator.defaultInstance();
private static Context withSpanContext(SpanContext spanContext, Context context) {
return context.with(Span.wrap(spanContext));
}
private static SpanContext getSpanContext(Context context) {
return Span.fromContext(context).getSpanContext();
}
@Test
public void inject_map_Nothing() {
Map<String, String> carrier = new HashMap<>();
grpcTraceBinContextPropagator.inject(Context.current(), carrier, setter);
assertThat(carrier).hasSize(0);
}
@Test
public void inject_map_invalidSpan() {
Map<String, String> carrier = new HashMap<>();
Context context = withSpanContext(SpanContext.getInvalid(), Context.current());
grpcTraceBinContextPropagator.inject(context, carrier, setter);
assertThat(carrier).isEmpty();
}
@Test
public void inject_map_nullCarrier() {
Map<String, String> carrier = new HashMap<>();
Context context =
withSpanContext(
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
Context.current());
grpcTraceBinContextPropagator.inject(context, null,
(TextMapSetter<Map<String, String>>) (ignored, key, value) -> carrier.put(key, value));
assertThat(carrier)
.containsExactly(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeaderEncodedSampled);
}
@Test
public void inject_map_nullContext() {
Map<String, String> carrier = new HashMap<>();
grpcTraceBinContextPropagator.inject(null, carrier, setter);
assertThat(carrier).isEmpty();
}
@Test
public void inject_map_invalidBinaryFormat() {
GrpcTraceBinContextPropagator propagator = new GrpcTraceBinContextPropagator(
new Metadata.BinaryMarshaller<SpanContext>() {
@Override
public byte[] toBytes(SpanContext value) {
throw new IllegalArgumentException("failed to byte");
}
@Override
public SpanContext parseBytes(byte[] serialized) {
return null;
}
});
Map<String, String> carrier = new HashMap<>();
Context context =
withSpanContext(
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
Context.current());
propagator.inject(context, carrier, setter);
assertThat(carrier).hasSize(0);
}
@Test
public void inject_map_SampledContext() {
verify_inject_map(TraceFlags.getSampled(), goldenHeaderEncodedSampled);
}
@Test
public void inject_map_NotSampledContext() {
verify_inject_map(TraceFlags.getDefault(), goldenHeaderEncodedNotSampled);
}
private void verify_inject_map(TraceFlags traceFlags, String goldenHeader) {
Map<String, String> carrier = new HashMap<>();
Context context =
withSpanContext(
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()),
Context.current());
grpcTraceBinContextPropagator.inject(context, carrier, setter);
assertThat(carrier)
.containsExactly(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeader);
}
@Test
public void extract_map_nothing() {
Map<String, String> carrier = new HashMap<>();
assertThat(grpcTraceBinContextPropagator.extract(Context.current(), carrier, getter))
.isSameInstanceAs(Context.current());
}
@Test
public void extract_map_SampledContext() {
verify_extract_map(TraceFlags.getSampled(), goldenHeaderEncodedSampled);
}
@Test
public void extract_map_NotSampledContext() {
verify_extract_map(TraceFlags.getDefault(), goldenHeaderEncodedNotSampled);
}
private void verify_extract_map(TraceFlags traceFlags, String goldenHeader) {
Map<String, String> carrier = ImmutableMap.of(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeader);
Context result = grpcTraceBinContextPropagator.extract(Context.current(), carrier, getter);
assertThat(getSpanContext(result)).isEqualTo(SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()));
}
@Test
public void inject_metadata_Nothing() {
Metadata carrier = new Metadata();
grpcTraceBinContextPropagator.inject(Context.current(), carrier, MetadataSetter.getInstance());
assertThat(carrier.keys()).isEmpty();
}
@Test
public void inject_metadata_nullCarrier() {
Context context =
withSpanContext(
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
Context.current());
grpcTraceBinContextPropagator.inject(context, null, MetadataSetter.getInstance());
}
@Test
public void inject_metadata_invalidSpan() {
Metadata carrier = new Metadata();
Context context = withSpanContext(SpanContext.getInvalid(), Context.current());
grpcTraceBinContextPropagator.inject(context, carrier, MetadataSetter.getInstance());
assertThat(carrier.keys()).isEmpty();
}
@Test
public void inject_metadata_SampledContext() {
verify_inject_metadata(TraceFlags.getSampled(), hexStringToByteArray(TRACE_HEADER_SAMPLED));
}
@Test
public void inject_metadataSetter_NotSampledContext() {
verify_inject_metadata(TraceFlags.getDefault(), hexStringToByteArray(TRACE_HEADER_NOT_SAMPLED));
}
private void verify_inject_metadata(TraceFlags traceFlags, byte[] bytes) {
Metadata metadata = new Metadata();
Context context =
withSpanContext(
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()),
Context.current());
grpcTraceBinContextPropagator.inject(context, metadata, MetadataSetter.getInstance());
byte[] injected = metadata.get(Metadata.Key.of(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER));
assertTrue(Arrays.equals(injected, bytes));
}
@Test
public void extract_metadata_nothing() {
assertThat(grpcTraceBinContextPropagator.extract(
Context.current(), new Metadata(), MetadataGetter.getInstance()))
.isSameInstanceAs(Context.current());
}
@Test
public void extract_metadata_nullCarrier() {
assertThat(grpcTraceBinContextPropagator.extract(
Context.current(), null, MetadataGetter.getInstance()))
.isSameInstanceAs(Context.current());
}
@Test
public void extract_metadata_SampledContext() {
verify_extract_metadata(TraceFlags.getSampled(), TRACE_HEADER_SAMPLED);
}
@Test
public void extract_metadataGetter_NotSampledContext() {
verify_extract_metadata(TraceFlags.getDefault(), TRACE_HEADER_NOT_SAMPLED);
}
private void verify_extract_metadata(TraceFlags traceFlags, String hex) {
Metadata carrier = new Metadata();
carrier.put(Metadata.Key.of(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
hexStringToByteArray(hex));
Context result = grpcTraceBinContextPropagator.extract(Context.current(), carrier,
MetadataGetter.getInstance());
assertThat(getSpanContext(result)).isEqualTo(SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()));
}
@Test
public void extract_metadata_invalidBinaryFormat() {
GrpcTraceBinContextPropagator propagator = new GrpcTraceBinContextPropagator(
new Metadata.BinaryMarshaller<SpanContext>() {
@Override
public byte[] toBytes(SpanContext value) {
return new byte[0];
}
@Override
public SpanContext parseBytes(byte[] serialized) {
throw new IllegalArgumentException("failed to byte");
}
});
Metadata carrier = new Metadata();
carrier.put(Metadata.Key.of(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
hexStringToByteArray(TRACE_HEADER_SAMPLED));
assertThat(propagator.extract(Context.current(), carrier, MetadataGetter.getInstance()))
.isSameInstanceAs(Context.current());
}
@Test
public void extract_metadata_invalidBinaryFormatVersion() {
Metadata carrier = new Metadata();
carrier.put(Metadata.Key.of(
GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
hexStringToByteArray("0100" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0201"));
assertThat(grpcTraceBinContextPropagator.extract(
Context.current(), carrier, MetadataGetter.getInstance()))
.isSameInstanceAs(Context.current());
}
private static String encode(String hex) {
return BASE64_ENCODING_OMIT_PADDING.encode(hexStringToByteArray(hex));
}
private static byte[] hexStringToByteArray(String s) {
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+ Character.digit(s.charAt(i + 1), 16));
}
return data;
}
}

96
opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataGetterTest.java Normal file
View File

@ -0,0 +1,96 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import io.grpc.Metadata;
import java.nio.charset.Charset;
import java.util.Iterator;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class MetadataGetterTest {
private final MetadataGetter metadataGetter = MetadataGetter.getInstance();
@Test
public void getBinaryGrpcTraceBin() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
Metadata.Key<byte[]> grpc_trace_bin_key =
Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadata.put(grpc_trace_bin_key, b);
assertArrayEquals(b, metadataGetter.getBinary(metadata, "grpc-trace-bin"));
}
@Test
public void getBinaryEmptyMetadata() {
assertNull(metadataGetter.getBinary(new Metadata(), "grpc-trace-bin"));
}
@Test
public void getBinaryNotGrpcTraceBin() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
Metadata.Key<byte[]> grpc_trace_bin_key =
Metadata.Key.of("another-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadata.put(grpc_trace_bin_key, b);
assertNull(metadataGetter.getBinary(metadata, "another-bin"));
}
@Test
public void getTextEmptyMetadata() {
assertNull(metadataGetter.get(new Metadata(), "a-key"));
}
@Test
public void getTextBinHeader() {
assertNull(metadataGetter.get(new Metadata(), "a-key-bin"));
}
@Test
public void getTestGrpcTraceBin() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
Metadata.Key<byte[]> grpc_trace_bin_key =
Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadata.put(grpc_trace_bin_key, b);
assertEquals(BASE64_ENCODING_OMIT_PADDING.encode(b),
metadataGetter.get(metadata, "grpc-trace-bin"));
}
@Test
public void getText() {
Metadata metadata = new Metadata();
Metadata.Key<String> other_key =
Metadata.Key.of("other", Metadata.ASCII_STRING_MARSHALLER);
metadata.put(other_key, "header-value");
assertEquals("header-value", metadataGetter.get(metadata, "other"));
Iterator<String> iterator = metadataGetter.keys(metadata).iterator();
assertTrue(iterator.hasNext());
assertEquals("other", iterator.next());
assertFalse(iterator.hasNext());
}
}

83
opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataSetterTest.java Normal file
View File

@ -0,0 +1,83 @@
/*
* Copyright 2024 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.grpc.opentelemetry;
import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import io.grpc.Metadata;
import java.nio.charset.Charset;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class MetadataSetterTest {
private final MetadataSetter metadataSetter = MetadataSetter.getInstance();
@Test
public void setGrpcTraceBin() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
Metadata.Key<byte[]> grpc_trace_bin_key =
Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadataSetter.set(metadata, "grpc-trace-bin", b);
assertArrayEquals(b, metadata.get(grpc_trace_bin_key));
}
@Test
public void setOtherBinaryKey() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
Metadata.Key<byte[]> other_key =
Metadata.Key.of("for-test-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadataSetter.set(metadata, other_key.name(), b);
assertNull(metadata.get(other_key));
}
@Test
public void setText() {
Metadata metadata = new Metadata();
String v = "generated";
Metadata.Key<String> textKey =
Metadata.Key.of("text-key", Metadata.ASCII_STRING_MARSHALLER);
metadataSetter.set(metadata, textKey.name(), v);
assertEquals(metadata.get(textKey), v);
}
@Test
public void setTextBin() {
Metadata metadata = new Metadata();
Metadata.Key<byte[]> other_key =
Metadata.Key.of("for-test-bin", Metadata.BINARY_BYTE_MARSHALLER);
metadataSetter.set(metadata, other_key.name(), "generated");
assertNull(metadata.get(other_key));
}
@Test
public void setTextGrpcTraceBin() {
Metadata metadata = new Metadata();
byte[] b = "generated".getBytes(Charset.defaultCharset());
metadataSetter.set(metadata, "grpc-trace-bin", BASE64_ENCODING_OMIT_PADDING.encode(b));
Metadata.Key<byte[]> grpc_trace_bin_key =
Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
assertArrayEquals(metadata.get(grpc_trace_bin_key), b);
}
}