Make README example less pseudo-y

Author: bcomnes

README.md

@@ -29,35 +29,108 @@ It must be configured before defining routes and other plugins in order to cover
   - `onResponse`
   - `onError`
 - Instruments automatically custom 404 Not Found handler
+- TODO: Clarify server shutdown/cleanup around otel metrics/traces
 
-Example:
+## Example
 
 ```js
-// ... in your OTEL setup
-const FastifyOtelInstrumentation = require('@fastify/otel');
+// otej.js
+// This example sets up metrics and traces,
+// the http and node runtime insturmentations, as well as host metrics.
+const { NodeSDK } = require('@opentelemetry/sdk-node')
+const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http')
+const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus')
+const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
+const { RuntimeNodeInstrumentation } = require('@opentelemetry/instrumentation-runtime-node')
+const { HostMetrics } = require('@opentelemetry/host-metrics')
+const { FastifyOtelInstrumentation } = require('@fastify/otel')
+const { metrics, trace } = require('@opentelemetry/api')
+const { resourceFromAttributes } = require('@opentelemetry/resources')
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions')
+
+// OTLP/HTTP trace exporter
+const traceExporter = new OTLPTraceExporter({
+  url: 'http://localhost:4318/v1/traces',
+});
 
-// If serverName is not provided, it will fallback to OTEL_SERVICE_NAME
-// as per https://opentelemetry.io/docs/languages/sdk-configuration/general/.
-const fastifyOtelInstrumentation = new FastifyOtelInstrumentation({ servername: '<yourCustomApplicationName>' });
-fastifyOtelInstrumentation.setTracerProvider(provider)
+// Prometheus pull-based metrics exporter
+const prometheusExporter = new PrometheusExporter({ port: 9091 });
+
+export const sdk = new NodeSDK({
+  resource: resourceFromAttributes({
+    [SemanticResourceAttributes.SERVICE_NAME]: 'my-service-name',
+  }),
+  traceExporter,
+  metricReader: prometheusExporter,
+  instrumentations: [
+    new HttpInstrumentation(),
+    new RuntimeNodeInstrumentation(),
+  ],
+});
 
-module.exports = { fastifyOtelInstrumentation }
+await sdk.start();
 
-// ... in your Fastify definition
-const { fastifyOtelInstrumentation } = require('./otel.js');
-const Fastify = require('fastify');
+export const fastifyOtelInstrumentation = new FastifyOtelInstrumentation({
+  registerOnInitialization: true,     // auto-register on fastify() creation
+});
+fastifyOtelInstrumentation.setTracerProvider(trace.getTracerProvider());
 
-const app = fastify();
+new HostMetrics({ meterProvider: metrics.getMeterProvider() }).start();
+```
+
+If `registerOnInitialization=true`, use a loader to load your otel.js before everything else.
+
+[Fastify-cli](https://github.com/fastify/fastify-cli):
+
+- `fastify start --import otel.js` for esm
+- `fastify start --require otel.js` for cjs
+
+Node.js:
+
+- `node --import ./otel.js ./app.js` for esm
+- `node --require ./otel.js ./app.js` for cjs
+
+```js
+// app.js
+import Fastify from 'fastify';
+
+// create instance *after* OTEL has been bootstrapped so that
+// registerOnInitialization can hook into route creation
+const app = await Fastify();
+
+app.get('/', async () => 'hello world');
+
+app.get(
+  '/healthcheck',
+  { config: { otel: false } },       // skip tracing/metrics for this route
+  async () => 'Up!'
+);
+
+// example of encapsulated context with its own instrumentation
+app.register(async (instance) => {
+  // will inherit global FastifyOtelInstrumentation because we registered with
+  // registerOnInitialization
+  instance.get('/', async () => 'nested hello world');
+}, { prefix: '/nested' });
+
+await app.listen({ port: 3000 });
+console.log('⚡ Fastify listening on http://localhost:3000');
+````
+
+### Manual plugin registration
+
+If `registerOnInitialization=false`, you must register the fastify plugin before defining any routes.
+
+```js
+import Fastify from 'fastify';
+import { fastifyOtelInstrumentation } from './otel.js';
+
+const app = await Fastify();
 // It is necessary to await for its register as it requires to be able
 // to intercept all route definitions
 await app.register(fastifyOtelInstrumentation.plugin());
 
-// automatically all your routes will be instrumented
-app.get('/', () => 'hello world')
-// as well as your instance level hooks.
-app.addHook('onError', () => /* do something */)
-// Manually skip telemetry for a specific route
-app.get('/healthcheck', { config: { otel: false } }, () => 'Up!')
+app.get('/', async () => 'hello world');
 
 // you can also scope your instrumentation to only be enabled on a sub context
 // of your application
@@ -69,23 +142,7 @@ app.register((instance, opts, done) => {
 
     done()
 }, { prefix: '/nested' })
-```
-
-### Automatic plugin registration
-
-The plugin can be automatically registered with `registerOnInitialization` option set to `true`.
-In this case, it is necessary to await fastify instance.
-
-```js
-// ... in your OTEL setup
-const fastifyOtelInstrumentation = new FastifyOtelInstrumentation({
-  registerOnInitialization: true,
-});
-
-// ... in your Fastify definition
-const Fastify = require('fastify');
-const app = await fastify();
-```
+````
 
 > **Notes**:
 >