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

simplify the Jaeger integration test (#2806) 

* simplify the Jaeger integration test

* remove un-needed shadow plugin
This commit is contained in:
John Watson 2021-02-12 12:18:45 -08:00 committed by GitHub
parent 1fc7e057ad
commit 61ef25befe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 69 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
integration-tests/build.gradle
View File

@ -1,7 +1,5 @@
plugins {
id "java"
id "com.github.johnrengelman.shadow"
}
description = 'OpenTelemetry Integration Tests'
@ -18,9 +16,5 @@ dependencies {
"org.testcontainers:junit-jupiter",
"com.squareup.okhttp3:okhttp"
tasks.withType(Test) {
dependsOn shadowJar
systemProperty 'archive.name', shadowJar.archiveFile.get().asFile.absolutePath
}
}

101
integration-tests/src/main/java/io/opentelemetry/SendTraceToJaeger.java
View File

@ -1,101 +0,0 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;
import java.time.Duration;
public class SendTraceToJaeger {
// Jaeger Endpoint URL and PORT
private final String ip; // = "jaeger";
private final int port; // = 14250;
public SendTraceToJaeger(String ip, int port) {
this.ip = ip;
this.port = port;
}
private OpenTelemetry initOpenTelemetry() {
// Create a channel towards Jaeger end point
ManagedChannel jaegerChannel =
ManagedChannelBuilder.forAddress(ip, port).usePlaintext().build();
// Export traces to Jaeger
JaegerGrpcSpanExporter jaegerExporter =
JaegerGrpcSpanExporter.builder()
.setChannel(jaegerChannel)
.setTimeout(Duration.ofSeconds(30))
.build();
// Set to process the spans by the Jaeger Exporter
return OpenTelemetrySdk.builder()
.setTracerProvider(
SdkTracerProvider.builder()
.addSpanProcessor(SimpleSpanProcessor.create(jaegerExporter))
.setResource(
Resource.getDefault()
.merge(
Resource.create(
Attributes.of(
ResourceAttributes.SERVICE_NAME, "integration test"))))
.build())
.buildAndRegisterGlobal();
}
private static void myWonderfulUseCase(OpenTelemetry openTelemetry) {
// Generate a span
Span span =
openTelemetry
.getTracer("io.opentelemetry.SendTraceToJaeger")
.spanBuilder("Start my wonderful use case")
.startSpan();
span.addEvent("Event 0");
// execute my use case - here we simulate a wait
doWait();
span.addEvent("Event 1");
span.end();
}
private static void doWait() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// catch
}
}
/**
* Main method.
*
* @param args args
*/
public static void main(String[] args) {
// Parsing the input
if (args.length < 2) {
System.out.println("Missing [hostname] [port]");
System.exit(1);
}
String ip = args[0];
int port = Integer.parseInt(args[1]);
// Start the example
SendTraceToJaeger example = new SendTraceToJaeger(ip, port);
OpenTelemetry openTelemetry = example.initOpenTelemetry();
myWonderfulUseCase(openTelemetry);
// wait some seconds
doWait();
System.out.println("Bye");
}
}

99
integration-tests/src/test/java/io/opentelemetry/JaegerExporterIntegrationTest.java
View File

@ -7,6 +7,17 @@ package io.opentelemetry;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;
import java.time.Duration;
import okhttp3.OkHttpClient;
import okhttp3.Request;
@ -19,7 +30,6 @@ import org.testcontainers.containers.wait.strategy.Wait;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;
import org.testcontainers.utility.MountableFile;
/**
* Integration test to verify that OpenTelemetry artefacts run in JRE 7.
@ -37,53 +47,34 @@ class JaegerExporterIntegrationTest {
private static final ObjectMapper objectMapper = new ObjectMapper();
private static final OkHttpClient client = new OkHttpClient();
private static final String ARCHIVE_NAME = System.getProperty("archive.name");
private static final String APP_NAME = "SendTraceToJaeger.jar";
private static final int QUERY_PORT = 16686;
private static final int COLLECTOR_PORT = 14250;
private static final int JAEGER_API_PORT = 14250;
private static final int HEALTH_PORT = 14269;
private static final String SERVICE_NAME = "integration test";
private static final String JAEGER_HOSTNAME = "jaeger";
private static final String JAEGER_URL = "http://localhost";
private static final Network network = Network.SHARED;
@SuppressWarnings("rawtypes")
@Container
public static GenericContainer jaegerContainer =
public static GenericContainer<?> jaegerContainer =
new GenericContainer<>(
DockerImageName.parse("ghcr.io/open-telemetry/java-test-containers:jaeger"))
.withNetwork(network)
.withNetworkAliases(JAEGER_HOSTNAME)
.withExposedPorts(COLLECTOR_PORT, QUERY_PORT, HEALTH_PORT)
.withExposedPorts(JAEGER_API_PORT, QUERY_PORT, HEALTH_PORT)
.waitingFor(Wait.forHttp("/").forPort(HEALTH_PORT));
@SuppressWarnings("rawtypes")
@Container
public static GenericContainer jaegerExampleAppContainer =
new GenericContainer(
DockerImageName.parse("ghcr.io/open-telemetry/java-test-containers:openjdk8"))
.withNetwork(network)
.withCopyFileToContainer(MountableFile.forHostPath(ARCHIVE_NAME), "/app/" + APP_NAME)
.withCommand(
"java",
"-cp",
"/app/" + APP_NAME,
"io.opentelemetry.SendTraceToJaeger",
JAEGER_HOSTNAME,
Integer.toString(COLLECTOR_PORT))
.waitingFor(Wait.forLogMessage(".*Bye.*", 1).withStartupTimeout(Duration.ofMinutes(2)))
.dependsOn(jaegerContainer);
@Test
void testJaegerExampleAppIntegration() {
OpenTelemetry openTelemetry =
initOpenTelemetry(
jaegerContainer.getHost(), jaegerContainer.getMappedPort(JAEGER_API_PORT));
myWonderfulUseCase(openTelemetry);
Awaitility.await()
.atMost(Duration.ofSeconds(30))
.until(JaegerExporterIntegrationTest::assertJaegerHaveTrace);
.until(JaegerExporterIntegrationTest::assertJaegerHasTheTrace);
}
private static Boolean assertJaegerHaveTrace() {
private static Boolean assertJaegerHasTheTrace() {
try {
String url =
String.format(
@ -108,4 +99,52 @@ class JaegerExporterIntegrationTest {
return false;
}
}
private static OpenTelemetry initOpenTelemetry(String ip, int port) {
// Create a channel towards Jaeger end point
ManagedChannel jaegerChannel =
ManagedChannelBuilder.forAddress(ip, port).usePlaintext().build();
// Export traces to Jaeger
JaegerGrpcSpanExporter jaegerExporter =
JaegerGrpcSpanExporter.builder()
.setChannel(jaegerChannel)
.setTimeout(Duration.ofSeconds(30))
.build();
// Set to process the spans by the Jaeger Exporter
return OpenTelemetrySdk.builder()
.setTracerProvider(
SdkTracerProvider.builder()
.addSpanProcessor(SimpleSpanProcessor.create(jaegerExporter))
.setResource(
Resource.getDefault()
.merge(
Resource.create(
Attributes.of(
ResourceAttributes.SERVICE_NAME, "integration test"))))
.build())
.buildAndRegisterGlobal();
}
private static void myWonderfulUseCase(OpenTelemetry openTelemetry) {
// Generate a span
Span span =
openTelemetry
.getTracer("io.opentelemetry.SendTraceToJaeger")
.spanBuilder("Start my wonderful use case")
.startSpan();
span.addEvent("Event 0");
// execute my use case - here we simulate a wait
doWait();
span.addEvent("Event 1");
span.end();
}
private static void doWait() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// catch
}
}
}