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

Add grpc example (#696) 

* Add build files for gRPC example
This commit is contained in:
Giovanni Liva 2020-04-01 17:14:46 +02:00 committed by GitHub
parent 83eb97ee3c
commit 498e101bdf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 960 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
examples/grpc/README.md Normal file
View File

@ -0,0 +1,34 @@
# gRPC Example
**Note:** This is an advanced scenario useful for people that want to *manually* instrument their own code.
This example demonstrates how to use the OpenTelemetry SDK
to instrument normal and streamed gRPC calls.
The example creates the **Root Span** on the client and sends the distributed context
over the gRPC request. On the server side, the example shows how to extract the context
and create a **Child Span**.
# How to run
## Prerequisites
* Java 1.8
## 1 - Compile
```bash
gradlew fatJar
```
## 2 - Start the Server
```bash
java -cp ./build/libs/opentelemetry-example-grpc-all-0.1.0-SNAPSHOT.jar io.opentelemetry.example.HelloWorldServer
```
## 3 - Start the normal Client
```bash
java -cp ./build/libs/opentelemetry-example-grpc-all-0.1.0-SNAPSHOT.jar io.opentelemetry.example.HelloWorldClient
```
## 4 - Start the streamed Client
```bash
java -cp ./build/libs/opentelemetry-example-grpc-all-0.1.0-SNAPSHOT.jar io.opentelemetry.example.HelloWorldClientStream
```

62
examples/grpc/build.gradle Normal file
View File

@ -0,0 +1,62 @@
plugins {
// ASSUMES GRADLE 2.12 OR HIGHER. Use plugin version 0.7.5 with earlier gradle versions
id 'com.google.protobuf' version '0.8.8'
// Generate IntelliJ IDEA's .idea & .iml project files
id 'java'
}
apply plugin: 'com.google.protobuf'
group 'io.opentelemetry'
version '0.1.0-SNAPSHOT'
def opentelemetryVersion = '0.3.0'
def grpcVersion = '1.24.0' // CURRENT_GRPC_VERSION
def protobufVersion = '3.10.0'
def protocVersion = protobufVersion
repositories {
mavenCentral()
}
dependencies {
compile "io.opentelemetry:opentelemetry-api:${opentelemetryVersion}"
compile "io.opentelemetry:opentelemetry-sdk:${opentelemetryVersion}"
compile "io.opentelemetry:opentelemetry-exporters-logging:${opentelemetryVersion}"
compile "io.grpc:grpc-protobuf:${grpcVersion}"
compile "io.grpc:grpc-stub:${grpcVersion}"
compile "io.grpc:grpc-netty-shaded:${grpcVersion}"
testCompile group: 'junit', name: 'junit', version: '4.12'
}
protobuf {
protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
plugins {
grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
}
generateProtoTasks {
all()*.plugins { grpc {} }
}
}
// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
sourceSets {
main {
java {
srcDirs 'build/generated/source/proto/main/grpc'
srcDirs 'build/generated/source/proto/main/java'
}
}
}
//create a single Jar with all dependencies
task fatJar(type: Jar) {
baseName = project.name + '-all'
from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
with jar
}

BIN
examples/grpc/gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

6
examples/grpc/gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@ -0,0 +1,6 @@
#Fri Dec 06 12:31:29 CET 2019
distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStorePath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME

172
examples/grpc/gradlew vendored Executable file
View File

@ -0,0 +1,172 @@
#!/usr/bin/env sh
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=$(save "$@")
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")"
fi
exec "$JAVACMD" "$@"

84
examples/grpc/gradlew.bat vendored Normal file
View File

@ -0,0 +1,84 @@
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

2
examples/grpc/settings.gradle Normal file
View File

@ -0,0 +1,2 @@
rootProject.name = 'opentelemetry-example-grpc'

163
examples/grpc/src/main/java/io/opentelemetry/example/HelloWorldClient.java Normal file
View File

@ -0,0 +1,163 @@
/*
* Copyright 2015 The gRPC Authors
* Copyright 2019, OpenTelemetry 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.opentelemetry.example;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.Context;
import io.grpc.ForwardingClientCall;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.StatusRuntimeException;
import io.opentelemetry.OpenTelemetry;
import io.opentelemetry.context.Scope;
import io.opentelemetry.context.propagation.HttpTextFormat;
import io.opentelemetry.exporters.logging.LoggingSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpansProcessor;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.Tracer;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
public class HelloWorldClient {
private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
private final ManagedChannel channel;
private final String serverHostname;
private final Integer serverPort;
private final GreeterGrpc.GreeterBlockingStub blockingStub;
// OTel API
Tracer tracer =
OpenTelemetry.getTracerProvider().get("io.opentelemetry.example.HelloWorldClient");;
// Export traces as log
LoggingSpanExporter exporter = new LoggingSpanExporter();
// Share context via text headers
HttpTextFormat textFormat = OpenTelemetry.getPropagators().getHttpTextFormat();
// Inject context into the gRPC request metadata
HttpTextFormat.Setter<Metadata> setter =
new HttpTextFormat.Setter<Metadata>() {
@Override
public void set(Metadata carrier, String key, String value) {
carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
}
};
/** Construct client connecting to HelloWorld server at {@code host:port}. */
public HelloWorldClient(String host, int port) {
this.serverHostname = host;
this.serverPort = port;
this.channel =
ManagedChannelBuilder.forAddress(host, port)
// Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
// needing certificates.
.usePlaintext()
// Intercept the request to tag the span context
.intercept(new OpenTelemetryClientInterceptor())
.build();
blockingStub = GreeterGrpc.newBlockingStub(channel);
// Initialize the OTel tracer
initTracer();
}
private void initTracer() {
// Use the OpenTelemetry SDK
TracerSdkProvider tracerProvider = OpenTelemetrySdk.getTracerProvider();
// Set to process the spans by the log exporter
tracerProvider.addSpanProcessor(SimpleSpansProcessor.newBuilder(exporter).build());
}
public void shutdown() throws InterruptedException {
channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
}
/** Say hello to server. */
public void greet(String name) {
logger.info("Will try to greet " + name + " ...");
// Start a span
Span span =
tracer.spanBuilder("helloworld.Greeter/SayHello").setSpanKind(Span.Kind.CLIENT).startSpan();
span.setAttribute("component", "grpc");
span.setAttribute("rpc.service", "Greeter");
span.setAttribute("net.peer.ip", this.serverHostname);
span.setAttribute("net.peer.port", this.serverPort);
// Set the context with the current span
try (Scope scope = tracer.withSpan(span)) {
HelloRequest request = HelloRequest.newBuilder().setName(name).build();
try {
HelloReply response = blockingStub.sayHello(request);
span.setStatus(Status.OK);
logger.info("Greeting: " + response.getMessage());
} catch (StatusRuntimeException e) {
logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
// TODO create mapping for io.grpc.Status<->io.opentelemetry.trace.Status
span.setStatus(Status.UNKNOWN.withDescription("gRPC status: " + e.getStatus()));
return;
}
} finally {
span.end();
}
}
public class OpenTelemetryClientInterceptor implements ClientInterceptor {
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions, Channel channel) {
return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
channel.newCall(methodDescriptor, callOptions)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
// Inject the request with the current context
textFormat.inject(Context.current(), headers, setter);
// Perform the gRPC request
super.start(responseListener, headers);
}
};
}
}
/**
* Greet server. If provided, the first element of {@code args} is the name to use in the
* greeting.
*/
public static void main(String[] args) throws Exception {
// Access a service running on the local machine on port 50051
HelloWorldClient client = new HelloWorldClient("localhost", 50051);
try {
String user = "world";
// Use the arg as the name to greet if provided
if (args.length > 0) {
user = args[0];
}
client.greet(user);
} finally {
client.shutdown();
}
}
}

204
examples/grpc/src/main/java/io/opentelemetry/example/HelloWorldClientStream.java Normal file
View File

@ -0,0 +1,204 @@
/*
* Copyright 2015 The gRPC Authors
* Copyright 2019, OpenTelemetry 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.opentelemetry.example;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.Context;
import io.grpc.ForwardingClientCall;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
import io.opentelemetry.OpenTelemetry;
import io.opentelemetry.context.Scope;
import io.opentelemetry.context.propagation.HttpTextFormat;
import io.opentelemetry.exporters.logging.LoggingSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpansProcessor;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.Tracer;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
public class HelloWorldClientStream {
private static final Logger logger = Logger.getLogger(HelloWorldClientStream.class.getName());
private final ManagedChannel channel;
private final String serverHostname;
private final Integer serverPort;
private final GreeterGrpc.GreeterStub asyncStub;
// OTel API
Tracer tracer =
OpenTelemetry.getTracerProvider().get("io.opentelemetry.example.HelloWorldClient");;
// Export traces as log
LoggingSpanExporter exporter = new LoggingSpanExporter();
// Share context via text headers
HttpTextFormat textFormat = OpenTelemetry.getPropagators().getHttpTextFormat();
// Inject context into the gRPC request metadata
HttpTextFormat.Setter<Metadata> setter = new HttpTextFormat.Setter<Metadata>() {
@Override
public void set(Metadata carrier, String key, String value) {
carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
}
};
/** Construct client connecting to HelloWorld server at {@code host:port}. */
public HelloWorldClientStream(String host, int port) {
this.serverHostname = host;
this.serverPort = port;
this.channel =
ManagedChannelBuilder.forAddress(host, port)
// Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
// needing certificates.
.usePlaintext()
// Intercept the request to tag the span context
.intercept(new OpenTelemetryClientInterceptor())
.build();
asyncStub = GreeterGrpc.newStub(channel);
// Initialize the OTel tracer
initTracer();
}
private void initTracer() {
// Use the OpenTelemetry SDK
TracerSdkProvider tracerProvider = OpenTelemetrySdk.getTracerProvider();
// Set to process the spans by the log exporter
tracerProvider.addSpanProcessor(SimpleSpansProcessor.newBuilder(exporter).build());
}
public void shutdown() throws InterruptedException {
channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
}
/** Say hello to server. */
public void greet(List<String> names) {
logger.info("Will try to greet " + Arrays.toString(names.toArray()) + " ...");
// Start a span
Span span =
tracer.spanBuilder("helloworld.Greeter/SayHello").setSpanKind(Span.Kind.CLIENT).startSpan();
span.setAttribute("component", "grpc");
span.setAttribute("rpc.service", "Greeter");
span.setAttribute("net.peer.ip", this.serverHostname);
span.setAttribute("net.peer.port", this.serverPort);
StreamObserver<HelloRequest> requestObserver = null;
// Set the context with the current span
try (Scope scope = tracer.withSpan(span)) {
HelloReplyStreamObserver replyObserver = new HelloReplyStreamObserver();
requestObserver = asyncStub.sayHelloStream(replyObserver);
for(String name : names){
try {
requestObserver.onNext(HelloRequest.newBuilder().setName(name).build());
// Sleep for a bit before sending the next one.
Thread.sleep(500);
} catch (InterruptedException e) {
logger.log(Level.WARNING, "RPC failed: {0}", e.getMessage());
requestObserver.onError(e);
}
}
requestObserver.onCompleted();
span.addEvent("Done sending");
span.setStatus(Status.OK);
} catch (StatusRuntimeException e){
logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
// TODO create mapping for io.grpc.Status<->io.opentelemetry.trace.Status
span.setStatus(Status.UNKNOWN.withDescription("gRPC status: " + e.getStatus()));
return;
} finally {
span.end();
}
}
private class HelloReplyStreamObserver implements StreamObserver<HelloReply> {
public HelloReplyStreamObserver() {
logger.info("Greeting: ");
}
@Override
public void onNext(HelloReply value) {
Span span = tracer.getCurrentSpan();
span.addEvent("Data received: " + value.getMessage());
logger.info(value.getMessage());
}
@Override
public void onError(Throwable t) {
Span span = tracer.getCurrentSpan();
logger.log(Level.WARNING, "RPC failed: {0}", t.getMessage());
// TODO create mapping for io.grpc.Status<->io.opentelemetry.trace.Status
span.setStatus(Status.UNKNOWN.withDescription("gRPC status: " + t.getMessage()));
}
@Override
public void onCompleted() {
//Since onCompleted is async and the span.end() is called in the main thread,
//it is recommended to set the span Status in the main thread.
}
}
public class OpenTelemetryClientInterceptor implements ClientInterceptor {
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions, Channel channel) {
return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
channel.newCall(methodDescriptor, callOptions)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
// Inject the request with the current context
textFormat.inject(Context.current(), headers, setter);
// Perform the gRPC request
super.start(responseListener, headers);
}
};
}
}
/**
* Greet server. If provided, the first element of {@code args} is the name to use in the
* greeting.
*/
public static void main(String[] args) throws Exception {
// Access a service running on the local machine on port 50051
HelloWorldClientStream client = new HelloWorldClientStream("localhost", 50051);
try {
List<String> users = Arrays.asList("world", "this", "is", "a", "list", "of", "names");
// Use the arg as the name to greet if provided
if (args.length > 0) {
users = Arrays.asList(args);
}
client.greet(users);
} finally {
client.shutdown();
}
}
}

195
examples/grpc/src/main/java/io/opentelemetry/example/HelloWorldServer.java Normal file
View File

@ -0,0 +1,195 @@
/*
* Copyright 2015 The gRPC Authors
* Copyright 2019, OpenTelemetry 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.opentelemetry.example;
import io.grpc.Context;
import io.grpc.Contexts;
import io.grpc.Grpc;
import io.grpc.Metadata;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.ServerCall;
import io.grpc.ServerCallHandler;
import io.grpc.stub.StreamObserver;
import io.opentelemetry.OpenTelemetry;
import io.opentelemetry.context.ContextUtils;
import io.opentelemetry.context.Scope;
import io.opentelemetry.context.propagation.HttpTextFormat;
import io.opentelemetry.exporters.logging.LoggingSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpansProcessor;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.Tracer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.logging.Logger;
/** Server that manages startup/shutdown of a {@code Greeter} server. */
public class HelloWorldServer {
private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
private Server server;
private final int port = 50051;
// OTel API
Tracer tracer = OpenTelemetry.getTracerProvider().get("io.opentelemetry.example.HelloWorldServer");
// Export traces as log
LoggingSpanExporter exporter = new LoggingSpanExporter();
// Share context via text
HttpTextFormat textFormat = OpenTelemetry.getPropagators().getHttpTextFormat();;
// Extract the Distributed Context from the gRPC metadata
HttpTextFormat.Getter<Metadata> getter =
new HttpTextFormat.Getter<Metadata>() {
@Override
public String get(Metadata carrier, String key) {
Metadata.Key<String> k = Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER);
if (carrier.containsKey(k)) {
return carrier.get(k);
}
return "";
}
};
public HelloWorldServer() {
initTracer();
}
private void start() throws IOException {
/* The port on which the server should run */
server =
ServerBuilder.forPort(this.port)
.addService(new GreeterImpl())
// Intercept gRPC calls
.intercept(new OpenTelemetryServerInterceptor())
.build()
.start();
logger.info("Server started, listening on " + port);
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
@Override
public void run() {
// Use stderr here since the logger may have been reset by its JVM shutdown hook.
System.err.println("*** shutting down gRPC server since JVM is shutting down");
HelloWorldServer.this.stop();
System.err.println("*** server shut down");
System.err.println(
"*** forcing also the Tracer Exporter to shutdown and process the remaining traces");
exporter.shutdown();
System.err.println("*** Trace Exporter shut down");
}
});
}
private void stop() {
if (server != null) {
server.shutdown();
}
}
private void initTracer() {
// Get the tracer
TracerSdkProvider tracerProvider = OpenTelemetrySdk.getTracerProvider();
// Set to process the the spans by the LogExporter
tracerProvider.addSpanProcessor(SimpleSpansProcessor.newBuilder(exporter).build());
}
/** Await termination on the main thread since the grpc library uses daemon threads. */
private void blockUntilShutdown() throws InterruptedException {
if (server != null) {
server.awaitTermination();
}
}
class GreeterImpl extends GreeterGrpc.GreeterImplBase {
// We serve a normal gRPC call
@Override
public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
// Serve the request
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
}
// We serve a stream gRPC call
@Override
public StreamObserver<HelloRequest> sayHelloStream(final StreamObserver<HelloReply> responseObserver) {
return new StreamObserver<HelloRequest>() {
@Override
public void onNext(HelloRequest value) {
responseObserver.onNext(
HelloReply.newBuilder().setMessage("Hello " + value.getName()).build()
);
}
@Override
public void onError(Throwable t) {
logger.info("[Error] " + t.getMessage());
responseObserver.onError(t);
}
@Override
public void onCompleted() {
responseObserver.onCompleted();
}
};
}
}
private class OpenTelemetryServerInterceptor implements io.grpc.ServerInterceptor {
@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
// Extract the Span Context from the metadata of the gRPC request
Context extractedContext = textFormat.extract(Context.current(),headers, getter);
InetSocketAddress clientInfo =
(InetSocketAddress) call.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
// Build a span based on the received context
try (Scope scope = ContextUtils.withScopedContext(extractedContext)) {
Span span =
tracer
.spanBuilder("helloworld.Greeter/SayHello")
.setSpanKind(Span.Kind.SERVER)
.startSpan();
span.setAttribute("component", "grpc");
span.setAttribute("rpc.service", "Greeter");
span.setAttribute("net.peer.ip", clientInfo.getHostString());
span.setAttribute("net.peer.port", clientInfo.getPort());
// Process the gRPC call normally
try {
span.setStatus(Status.OK);
return Contexts.interceptCall(Context.current(), call, headers, next);
} finally {
span.end();
}
}
}
}
/** Main launches the server from the command line. */
public static void main(String[] args) throws IOException, InterruptedException {
final HelloWorldServer server = new HelloWorldServer();
server.start();
server.blockUntilShutdown();
}
}

38
examples/grpc/src/main/proto/helloworld.proto Normal file
View File

@ -0,0 +1,38 @@
// Copyright 2015 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.
syntax = "proto3";
option java_multiple_files = true;
option java_package = "io.opentelemetry.example";
option java_outer_classname = "HelloWorldProto";
package helloworld;
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
rpc SayHelloStream (stream HelloRequest) returns (stream HelloReply) {}
}
// The request message containing the user's name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}