Add nodejs tutorial (yurishkuro#5)

Author: junminstorage

nodejs/lesson01/README.md

@@ -0,0 +1,45 @@
+**NOTE**
+
+This README is currently incomplete / unfinished. Please refer to respective README in tutorials for one of the other languages
+
+
+# Lesson 1 - Hello World
+
+## Objectives
+
+Learn how to:
+
+* Instantiate a Tracer
+* Create a simple trace
+* Annotate the trace
+
+## Walkthrough
+
+### A simple Hello-World program
+
+
+Run it:
+```
+npm install
+node lesson01/solution/hello.js Peter
+INFO  Initializing Jaeger Tracer with CompositeReporter and ConstSampler
+Hello app listening on port 8080
+
+```
+
+Run the following curl command a few times:
+
+```
+curl localhost:8080
+```
+
+You should see something below on the console for the client app:
+
+```
+Hello, Peter!
+INFO  Reporting span 6d8e165388a35fb5:6d8e165388a35fb5:0:1
+Hello, Peter!
+INFO  Reporting span 48b662d422dfcc86:48b662d422dfcc86:0:1
+Hello, Peter!
+INFO  Reporting span c0e45d92229168c5:c0e45d92229168c5:0:1
+```

nodejs/lesson01/solution/hello.js

@@ -1,39 +1,33 @@
 'use strict';
 
-var express = require('express')
-var app = express()
-var initTracer = require('../../lib/tracing').initTracer;
-
-app.get('/', function (req, res) {
-    var helloStr = sayHello(helloTo);
-    res.send(helloStr)
-})
+const assert = require('assert');
+const initTracer = require('../../lib/tracing').initTracer;
 
 function sayHello(helloTo) {
     var span = tracer.startSpan('say-hello');
-    
-    var helloStr = 'Hello, ' + helloTo + '!';
+    span.setTag('hello-to', helloTo);
+
+    var helloStr = `Hello, ${helloTo}!`;
     span.log({
-        'event': 'format-string',
+        'event': 'string-format',
         'value': helloStr
     });
 
     console.log(helloStr);
+
     span.log({'event': 'print-string'})
-    
     span.finish();
-
-    return helloStr;
 }  
 
-if (process.argv.length != 3) {
-    throw new Error('expecting one argument')
-}
+assert.ok(process.argv.length == 3, 'expecting one argument');
+
+const helloTo = process.argv[2];
+
+const tracer = initTracer('hello-world');
+
+sayHello(helloTo);
 
-var helloTo = process.argv[2];
+//wait for udp message sent out
+setTimeout( e => {tracer.close();}, 12000);
 
-var tracer = initTracer('hello-world');
 
-app.listen(8080, function () {
-    console.log('Hello app listening on port 8080')
-})

nodejs/lesson02/README.md

@@ -0,0 +1,40 @@
+**NOTE**
+
+This README is currently incomplete / unfinished. Please refer to respective README in tutorials for one of the other languages
+
+
+# Lesson 2 - Context and Tracing Functions
+
+## Objectives
+
+Learn how to:
+
+* Trace individual functions
+* Combine multiple spans into a single trace
+* Propagate the in-process context
+
+## Walkthrough
+
+### A simple Hello-World program
+
+```
+
+Run it:
+```
+npm install
+node lesson02/solution/hello.js Peter
+INFO  Initializing Jaeger Tracer with CompositeReporter and ConstSampler
+Hello app listening on port 8080
+
+```
+
+```
+
+You should see something below on the console for the client app:
+
+```
+INFO  Reporting span d6c674cb77b1ba9c:933a7b0d05ed1b48:d6c674cb77b1ba9c:1
+Hello, Peter!
+INFO  Reporting span d6c674cb77b1ba9c:263fe6d3cb907321:d6c674cb77b1ba9c:1
+INFO  Reporting span d6c674cb77b1ba9c:d6c674cb77b1ba9c:0:1
+```

nodejs/lesson02/solution/hello.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const assert = require('assert');
+const initTracer = require('../../lib/tracing').initTracer;
+
+function sayHello(helloTo) {
+    var span = tracer.startSpan('say-hello');
+    span.setTag('hello-to', helloTo);
+
+    var helloStr = format_string(helloTo, span);
+    
+    print_string(helloStr, span);
+    
+    span.finish();
+
+    return helloStr;
+}  
+
+function format_string(helloTo, root_span) {
+    var span = tracer.startSpan('format_string', {childOf: root_span.context()});
+    var formattedStr = `Hello, ${helloTo}!`;
+
+    span.log({
+        'event': 'format-string',
+        'value': helloTo
+    });
+
+    span.finish();    
+    return formattedStr;
+}
+
+function print_string(helloStr, root_span) {
+    var span = tracer.startSpan('print_string', {childOf: root_span.context()});
+
+    console.log(helloStr);
+
+    span.log({
+        'event': 'print-string',
+        'value': helloStr
+    });
+    span.finish();
+}
+  
+assert.ok(process.argv.length == 3, 'expecting one argument');
+
+const helloTo = process.argv[2];
+
+const tracer = initTracer('hello-world');
+
+sayHello(helloTo);
+
+setTimeout( e => {tracer.close();}, 12000);

nodejs/lesson03/README.md

@@ -0,0 +1,56 @@
+**NOTE**
+
+This README is currently incomplete / unfinished. Please refer to respective README in tutorials for one of the other languages
+
+
+# Lesson 3 - Tracing RPC Requests
+
+## Objectives
+
+Learn how to:
+
+* Trace a transaction across more than one microservice
+* Pass the context between processes using `Inject` and `Extract`
+* Apply OpenTracing-recommended tags
+
+## Walkthrough
+
+### Hello-World Microservice App
+
+To test it out, first run the formatter and publisher services in separate terminals
+
+```
+# terminal 1
+$ node lesson03/solution/formatter.js
+ * Running on http://localhost:8081/ (Press CTRL+C to quit)
+
+# terminal 3
+$ node lesson03/solution/publisher.js
+ * Running on http://localhost:8082/ (Press CTRL+C to quit)
+```
+
+Finally, if we run the client app as we did in the previous lessons:
+
+```
+$ node lesson03/solution/hello.js Peter
+INFO  Initializing Jaeger Tracer with CompositeReporter and ConstSampler
+Hello app listening on port 8080
+INFO  Reporting span 80c31f112061d86e:1def63dfd6d6755d:80c31f112061d86e:1
+INFO  Reporting span 80c31f112061d86e:e47ca83f948cb0c4:80c31f112061d86e:1
+INFO  Reporting span 80c31f112061d86e:80c31f112061d86e:0:1
+```
+
+On formatter terminal screen: 
+```
+INFO  Initializing Jaeger Tracer with CompositeReporter and ConstSampler
+Formatter app listening on port 8081
+INFO  Reporting span 80c31f112061d86e:9ad7c16acf5f0994:1def63dfd6d6755d:1
+```
+
+On publisher terminal screen:
+```
+INFO  Initializing Jaeger Tracer with CompositeReporter and ConstSampler
+Publisher app listening on port 8082
+Hello, Peter!
+INFO  Reporting span 80c31f112061d86e:f3211e5bb77c5f2b:e47ca83f948cb0c4:1
+```

nodejs/lesson03/solution/formatter.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const express = require('express')
+const app = express()
+const initTracer = require('../../lib/tracing').initTracer;
+const { Tags, FORMAT_HTTP_HEADERS } = require('opentracing');
+
+const tracer = initTracer('format-service');
+
+const port = 8081;
+
+app.listen(port, function () {
+    console.log('Formatter app listening on port ' + port);
+})
+
+app.get('/format', function (req, res) {
+    const parentSpanContext = tracer.extract(FORMAT_HTTP_HEADERS, req.headers)
+    const span = tracer.startSpan('http_server', {
+        childOf: parentSpanContext,
+        tags: {[Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_SERVER}
+    });
+
+    const helloTo= req.query.helloTo;
+
+    span.log({
+        'event': 'format',
+        'value': helloTo
+    });
+
+    span.finish();
+
+    res.send(`Hello, ${helloTo}!`);
+})
+
+
+

nodejs/lesson03/solution/hello.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const assert = require('assert');
+const initTracer = require('../../lib/tracing').initTracer;
+const request = require('request-promise');
+const { Tags, FORMAT_HTTP_HEADERS } = require('opentracing');
+
+function sayHello(helloTo) {
+
+    const span = tracer.startSpan('say-hello');
+    span.setTag('hello-to', helloTo);
+
+    format_string(helloTo, span)
+        .then( data => {
+            return print_hello(data, span);
+        })
+        .then( data => {
+            span.setTag(Tags.HTTP_STATUS_CODE, 200)
+            span.finish();
+        })
+        .catch( err => {
+            span.setTag(Tags.ERROR, true)
+            span.setTag(Tags.HTTP_STATUS_CODE, err.statusCode || 500);
+            span.finish();
+        });
+
+}
+
+function format_string(input, root_span) {
+    const url = `http://localhost:8081/format?helloTo=${input}`;
+    const fn = 'format';
+
+    const span = tracer.startSpan(fn, {childOf: root_span.context()});
+    span.log({
+        'event': 'format-string',
+        'value': input
+    });
+
+    return http_get(fn, url, span); 
+}  
+
+function print_hello(input, root_span) {
+    const url = `http://localhost:8082/publish?helloStr=${input}`;
+    const fn = 'publish';
+
+    const span = tracer.startSpan(fn, {childOf: root_span.context()});
+    span.log({
+        'event': 'print-string',
+        'value': input
+    });
+    return http_get(fn, url, span);
+}
+
+function http_get(fn, url, span) {
+    const method = 'GET';
+    const headers = {};
+    
+    span.setTag(Tags.HTTP_URL, url);
+    span.setTag(Tags.HTTP_METHOD, method);
+    span.setTag(Tags.SPAN_KIND, Tags.SPAN_KIND_RPC_CLIENT);
+    // Send span context via request headers (parent id etc.)
+    tracer.inject(span, FORMAT_HTTP_HEADERS, headers);
+
+    return request({url, method, headers})
+            .then( data => {
+                span.finish();
+                return data;
+            }, e => {
+                span.finish();
+                throw e;
+            });
+
+}
+
+assert.ok(process.argv.length == 3, 'expecting one argument');
+
+const helloTo = process.argv[2];
+
+const tracer = initTracer('hello-world');
+
+sayHello(helloTo);
+
+setTimeout( e => {tracer.close();}, 12000);
+
+
+  
+