@midwayjs/otel 3.0.0

package/README.md

@@ -0,0 +1,105 @@
+# midwayjs open-telemetry module
+
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
+
+this is a sub package for midway.
+
+
+## Install
+
+```bash
+$ npm install --save @opentelemetry/api
+$ npm install --save @opentelemetry/sdk-node
+$ npm install --save @opentelemetry/auto-instrumentations-node
+```
+
+Install component if you want decorator support.
+
+```bash
+$ npm i @midwayjs/otel@3 --save
+```
+
+## Enable open-telemetry
+
+open-telemetry must be loaded at the first of user code.
+
+you can add at `bootstrap.js`.
+
+```typescript
+const process = require('process');
+const opentelemetry = require('@opentelemetry/sdk-node');
+const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
+const { ConsoleSpanExporter } = require('@opentelemetry/sdk-trace-base');
+const { Resource } = require('@opentelemetry/resources');
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const { Bootstrap } = require('@midwayjs/bootstrap');
+
+// configure the SDK to export telemetry data to the console
+// enable all auto-instrumentations from the meta package
+const traceExporter = new ConsoleSpanExporter();
+const sdk = new opentelemetry.NodeSDK({
+  resource: new Resource({
+    [SemanticResourceAttributes.SERVICE_NAME]: 'my-service',
+  }),
+  traceExporter,
+  instrumentations: [getNodeAutoInstrumentations()]
+});
+
+// initialize the SDK and register with the OpenTelemetry API
+// this enables the API to record telemetry
+sdk.start()
+  .then(() => {
+    return Bootstrap
+      .configure(/**/)
+      .run();
+  });
+
+// gracefully shut down the SDK on process exit
+process.on('SIGTERM', () => {
+  sdk.shutdown()
+    .then(() => console.log('Tracing terminated'))
+    .catch((error) => console.log('Error terminating tracing', error))
+    .finally(() => process.exit(0));
+});
+```
+
+You can find more information at [opentelemetry-js](https://github.com/open-telemetry/opentelemetry-js)
+
+
+## Decorator Support
+
+Enable component first.
+
+```typescript
+import { Configuration } from '@midwayjs/decorator';
+import * as koa from '@midwayjs/koa';
+import * as otel from '@midwayjs/otel';
+
+@Configuration({
+  imports: [
+    koa,
+    otel
+  ]
+})
+export class MainConfiguration {
+}
+```
+
+Otel component add a @Trace decorator for method.
+
+```typescript
+export class UserService {
+
+  @Trace('user.get')
+  async getUser() {
+    // ...
+  }
+}
+```
+
+it will create a new span in current trace.
+
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -0,0 +1,8 @@
+import { MidwayDecoratorService } from '@midwayjs/core';
+import { TraceService } from './service';
+export declare class OtelConfiguration {
+    decoratorService: MidwayDecoratorService;
+    traceService: TraceService;
+    onReady(): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelConfiguration = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const core_1 = require("@midwayjs/core");
+const tracer_decorator_1 = require("./decorator/tracer.decorator");
+const service_1 = require("./service");
+const api_1 = require("@opentelemetry/api");
+let OtelConfiguration = class OtelConfiguration {
+    async onReady() {
+        this.decoratorService.registerMethodHandler(tracer_decorator_1.TRACE_KEY, options => {
+            return {
+                around: async (joinPoint) => {
+                    // 记录开始时间
+                    return this.traceService.createSpan(options.metadata['spanName'], async (span) => {
+                        try {
+                            // 执行原方法
+                            const result = await joinPoint.proceed(...joinPoint.args);
+                            span.setStatus({
+                                code: api_1.SpanStatusCode.OK,
+                            });
+                            span.end();
+                            // 返回执行结果
+                            return result;
+                        }
+                        catch (err) {
+                            span.setStatus({
+                                code: api_1.SpanStatusCode.ERROR,
+                            });
+                            span.recordException(err);
+                            span.end();
+                            throw err;
+                        }
+                    });
+                },
+            };
+        });
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], OtelConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", service_1.TraceService)
+], OtelConfiguration.prototype, "traceService", void 0);
+OtelConfiguration = __decorate([
+    (0, decorator_1.Configuration)({
+        namespace: 'otel',
+    })
+], OtelConfiguration);
+exports.OtelConfiguration = OtelConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/decorator/tracer.decorator.d.ts

@@ -0,0 +1,3 @@
+export declare const TRACE_KEY = "decorator:open_telemetry_key";
+export declare function Trace(spanName: string): MethodDecorator;
+//# sourceMappingURL=tracer.decorator.d.ts.map

package/dist/decorator/tracer.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trace = exports.TRACE_KEY = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+exports.TRACE_KEY = 'decorator:open_telemetry_key';
+function Trace(spanName) {
+    return (0, decorator_1.createCustomMethodDecorator)(exports.TRACE_KEY, {
+        spanName,
+    });
+}
+exports.Trace = Trace;
+//# sourceMappingURL=tracer.decorator.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { OtelConfiguration as Configuration } from './configuration';
+export * from './decorator/tracer.decorator';
+export * from './service';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.OtelConfiguration; } });
+__exportStar(require("./decorator/tracer.decorator"), exports);
+__exportStar(require("./service"), exports);
+//# sourceMappingURL=index.js.map

package/dist/service.d.ts

@@ -0,0 +1,11 @@
+import { Span } from '@opentelemetry/api';
+import { IMidwayApplication } from '@midwayjs/core';
+export declare class TraceService {
+    private currentTracerName;
+    protected app: IMidwayApplication;
+    protected init(): Promise<void>;
+    private getCurrentSpan;
+    getTraceId(): string;
+    createSpan(name: string, callback: (span: Span) => unknown): unknown;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const api_1 = require("@opentelemetry/api");
+let TraceService = class TraceService {
+    async init() {
+        var _a;
+        this.currentTracerName = (_a = this.app.getProjectName()) !== null && _a !== void 0 ? _a : 'unknown_project';
+    }
+    getCurrentSpan() {
+        return api_1.trace.getSpan(api_1.context.active());
+    }
+    getTraceId() {
+        return this.getCurrentSpan().spanContext().traceId;
+    }
+    createSpan(name, callback) {
+        return api_1.trace.getTracer(this.currentTracerName).startActiveSpan(name, {
+            kind: api_1.SpanKind.CLIENT,
+        }, callback);
+    }
+};
+__decorate([
+    (0, decorator_1.App)(),
+    __metadata("design:type", Object)
+], TraceService.prototype, "app", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TraceService.prototype, "init", null);
+TraceService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], TraceService);
+exports.TraceService = TraceService;
+//# sourceMappingURL=service.js.map

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    otel?: Record<string, any>;
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@midwayjs/otel",
+  "description": "midway open telemetry component",
+  "version": "3.0.0",
+  "main": "dist/index",
+  "typings": "index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@midwayjs/core": "^3.1.1",
+    "@midwayjs/decorator": "^3.0.10",
+    "@midwayjs/mock": "^3.1.1",
+    "@midwayjs/koa": "^3.1.1",
+    "@opentelemetry/core": "^1.0.1",
+    "@opentelemetry/sdk-trace-node": "^1.0.1",
+    "@opentelemetry/sdk-trace-base": "^1.0.1"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.0.3"
+  },
+  "keywords": [
+    "tracing",
+    "open-tracing",
+    "open-telemetry"
+  ],
+  "author": "czy88840616 <czy88840616@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "ci": "npm run test",
+    "lint": "mwts check"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/midwayjs/midway.git"
+  }
+}