Update lessons

java/run.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
 if [ "$1" == "" ]; then
-    echo "Usage: run.sh qualified-class-name [args]"
-    exit 1
+  echo "Usage: run.sh qualified-class-name [args]"
+  exit 1
 fi
 
 className=$1
@@ -17,4 +17,9 @@ for jar in $(ls target/dependency/*.jar target/java-opentracing-tutorial-*.jar);
   CLASSPATH=$CLASSPATH:$jar
 done
 
-java -cp $CLASSPATH $className $*
+ADD_MODULES=""
+if [ "$(java -version 2>&1 | head -1 | grep '\"1\.[78].\+\"')" = "" ]; then
+  ADD_MODULES="--add-modules=java.xml.bind"
+fi
+
+java $ADD_MODULES -cp $CLASSPATH $className $*

java/src/main/java/lesson01/README.md

@@ -64,7 +64,7 @@ public class Hello {
     }
 
     private void sayHello(String helloTo) {
-        Span span = tracer.buildSpan("say-hello").startManual();
+        Span span = tracer.buildSpan("say-hello").start();
 
         String helloStr = String.format("Hello, %s!", helloTo);
         System.out.println(helloStr);
@@ -85,7 +85,7 @@ public class Hello {
 We are using the following basic features of the OpenTracing API:
   * a `tracer` instance is used to create a span builder via `buildSpan()`
   * each `span` is given an _operation name_, `"say-hello"` in this case
-  * builder is used to create a span via `startManual()`
+  * builder is used to create a span via `start()`
   * each `span` must be finished by calling its `finish()` function
   * the start and end timestamps of the span will be captured automatically by the tracer implementation
 
@@ -101,7 +101,7 @@ Our `pom.xml` already imports Jaeger:
 <dependency>
     <groupId>com.uber.jaeger</groupId>
     <artifactId>jaeger-core</artifactId>
-    <version>0.26.0</version>
+    <version>0.27.0</version>
 </dependency>
 ```
 
@@ -113,9 +113,9 @@ import com.uber.jaeger.Configuration.ReporterConfiguration;
 import com.uber.jaeger.Configuration.SamplerConfiguration;
 
 public static com.uber.jaeger.Tracer initTracer(String service) {
-    SamplerConfiguration samplerConfig = new SamplerConfiguration("const", 1);
-    ReporterConfiguration reporterConfig = new ReporterConfiguration(true, null, null, null, null);
-    Configuration config = new Configuration(service, samplerConfig, reporterConfig);
+    SamplerConfiguration samplerConfig = new SamplerConfiguration().withType("const").withParam(1);
+    ReporterConfiguration reporterConfig = new ReporterConfiguration().withLogSpans(true);
+    Configuration config = new Configuration(service).withSampler(samplerConfig).withReporter(reporterConfig);
     return (com.uber.jaeger.Tracer) config.getTracer();
 }
 ```
@@ -177,7 +177,7 @@ In the case of `Hello Bryan`, the string `"Bryan"` is a good candidate for a spa
 to the whole span and not to a particular moment in time. We can record it like this:
 
 ```java
-Span span = tracer.buildSpan("say-hello").startManual();
+Span span = tracer.buildSpan("say-hello").start();
 span.setTag("hello-to", helloTo);
 ```
 

java/src/main/java/lesson01/solution/Hello.java

@@ -15,9 +15,9 @@ private Hello(Tracer tracer) {
     }
 
     private void sayHello(String helloTo) {
-        Span span = tracer.buildSpan("say-hello").startManual();
+        Span span = tracer.buildSpan("say-hello").start();
         span.setTag("hello-to", helloTo);
-        
+
         String helloStr = String.format("Hello, %s!", helloTo);
         span.log(ImmutableMap.of("event", "string-format", "value", helloStr));
 
@@ -32,8 +32,8 @@ public static void main(String[] args) {
             throw new IllegalArgumentException("Expecting one argument");
         }
         String helloTo = args[0];
-        Tracer tracer = Tracing.init("hello-world");
-        new Hello(tracer).sayHello(helloTo);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new Hello(tracer).sayHello(helloTo);
+        }
     }
 }

java/src/main/java/lesson02/README.md

@@ -42,7 +42,7 @@ Of course, this does not change the outcome. What we really want to do is to wra
 
 ```java
 private  String formatString(Span rootSpan, String helloTo) {
-    Span span = tracer.buildSpan("formatString").startManual();
+    Span span = tracer.buildSpan("formatString").start();
     try {
         String helloStr = String.format("Hello, %s!", helloTo);
         span.log(ImmutableMap.of("event", "string-format", "value", helloStr));
@@ -53,7 +53,7 @@ private  String formatString(Span rootSpan, String helloTo) {
 }
 
 private void printHello(Span rootSpan, String helloStr) {
-    Span span = tracer.buildSpan("printHello").startManual();
+    Span span = tracer.buildSpan("printHello").start();
     try {
         System.out.println(helloStr);
         span.log(ImmutableMap.of("event", "println"));
@@ -81,7 +81,7 @@ What we really wanted was to establish causal relationship between the two new s
 span started in `main()`. We can do that by passing an additional option `asChildOf` to the span builder:
 
 ```java
-Span span = tracer.buildSpan("formatString").asChildOf(rootSpan).startManual();
+Span span = tracer.buildSpan("formatString").asChildOf(rootSpan).start();
 ```
 
 If we think of the trace as a directed acyclic graph where nodes are the spans and edges are
@@ -121,7 +121,7 @@ You may have noticed a few unpleasant side effects of our recent changes
   * we also had to write somewhat verbose try/finally code to finish the spans
 
 OpenTracing API for Java provides a better way. Using thread-locals and the notion of an "active span",
-we can avoid passing the span through our code and just access it via `tracer.
+we can avoid passing the span through our code and just access it via `tracer`.
 
 ```java
 private void sayHello(String helloTo) {
@@ -150,7 +150,7 @@ private void printHello(String helloStr) {
 ```
 
 In the above code we're making the following changes:
-  * We use `startActive()` method of the span builder instead of `startManual()`,
+  * We use `startActive()` method of the span builder instead of `start()`,
     which makes the span "active" by storing it in a thread-local storage.
   * `startActive()` returns a `Scope` object instead of a `Span`. Scope is a container of the currently
     active span. We access the active span via `scope.span()`. Once the scope is closed, the previous

java/src/main/java/lesson02/solution/HelloActive.java

@@ -7,7 +7,7 @@
 import lib.Tracing;
 
 public class HelloActive {
-    
+
     private final Tracer tracer;
 
     private HelloActive(Tracer tracer) {
@@ -17,7 +17,7 @@ private HelloActive(Tracer tracer) {
     private void sayHello(String helloTo) {
         try (Scope scope = tracer.buildSpan("say-hello").startActive(true)) {
             scope.span().setTag("hello-to", helloTo);
-            
+
             String helloStr = formatString(helloTo);
             printHello(helloStr);
         }
@@ -43,8 +43,8 @@ public static void main(String[] args) {
             throw new IllegalArgumentException("Expecting one argument");
         }
         String helloTo = args[0];
-        Tracer tracer = Tracing.init("hello-world");
-        new HelloActive(tracer).sayHello(helloTo);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new HelloActive(tracer).sayHello(helloTo);
+        }
     }
 }

java/src/main/java/lesson02/solution/HelloManual.java

@@ -7,25 +7,25 @@
 import lib.Tracing;
 
 public class HelloManual {
-    
+
     private final Tracer tracer;
 
     private HelloManual(Tracer tracer) {
         this.tracer = tracer;
     }
 
     private void sayHello(String helloTo) {
-        Span span = tracer.buildSpan("say-hello").startManual();
+        Span span = tracer.buildSpan("say-hello").start();
         span.setTag("hello-to", helloTo);
-        
+
         String helloStr = formatString(span, helloTo);
         printHello(span, helloStr);
 
         span.finish();
     }
 
     private  String formatString(Span rootSpan, String helloTo) {
-        Span span = tracer.buildSpan("formatString").asChildOf(rootSpan).startManual();
+        Span span = tracer.buildSpan("formatString").asChildOf(rootSpan).start();
         try {
             String helloStr = String.format("Hello, %s!", helloTo);
             span.log(ImmutableMap.of("event", "string-format", "value", helloStr));
@@ -36,7 +36,7 @@ private  String formatString(Span rootSpan, String helloTo) {
     }
 
     private void printHello(Span rootSpan, String helloStr) {
-        Span span = tracer.buildSpan("printHello").asChildOf(rootSpan).startManual();
+        Span span = tracer.buildSpan("printHello").asChildOf(rootSpan).start();
         try {
             System.out.println(helloStr);
             span.log(ImmutableMap.of("event", "println"));
@@ -50,8 +50,8 @@ public static void main(String[] args) {
             throw new IllegalArgumentException("Expecting one argument");
         }
         String helloTo = args[0];
-        Tracer tracer = Tracing.init("hello-world");
-        new HelloManual(tracer).sayHello(helloTo);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new HelloManual(tracer).sayHello(helloTo);
+        }
     }
 }

java/src/main/java/lesson03/exercise/Hello.java

@@ -67,8 +67,8 @@ public static void main(String[] args) {
             throw new IllegalArgumentException("Expecting one argument");
         }
         String helloTo = args[0];
-        Tracer tracer = Tracing.init("hello-world");
-        new Hello(tracer).sayHello(helloTo);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new Hello(tracer).sayHello(helloTo);
+        }
     }
 }

java/src/main/java/lesson03/solution/Hello.java

@@ -75,8 +75,8 @@ public static void main(String[] args) {
             throw new IllegalArgumentException("Expecting one argument");
         }
         String helloTo = args[0];
-        Tracer tracer = Tracing.init("hello-world");
-        new Hello(tracer).sayHello(helloTo);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new Hello(tracer).sayHello(helloTo);
+        }
     }
 }

java/src/main/java/lesson04/README.md

@@ -36,9 +36,9 @@ public static void main(String[] args) {
     }
     String helloTo = args[0];
     String greeting = args[1];
-    Tracer tracer = Tracing.init("hello-world");
-    new Hello(tracer).sayHello(helloTo, greeting);
-    tracer.close();
+    try (Tracer tracer = Tracing.init("hello-world")) {
+        new Hello(tracer).sayHello(helloTo, greeting);
+    }
 }
 ```
 

java/src/main/java/lesson04/solution/Hello.java

@@ -77,8 +77,8 @@ public static void main(String[] args) {
         }
         String helloTo = args[0];
         String greeting = args[1];
-        Tracer tracer = Tracing.init("hello-world");
-        new Hello(tracer).sayHello(helloTo, greeting);
-        tracer.close();
+        try (Tracer tracer = Tracing.init("hello-world")) {
+            new Hello(tracer).sayHello(helloTo, greeting);
+        }
     }
 }