Added transports

plugins/node/opentelemetry-instrumentation-winston/package.json

@@ -59,14 +59,14 @@
     "sinon": "15.2.0",
     "test-all-versions": "5.0.1",
     "ts-mocha": "10.0.0",
-    "typescript": "4.4.4",
-    "winston": "3.3.3",
-    "winston2": "npm:[email protected]"
+    "typescript": "4.4.4"
   },
   "dependencies": {
     "@opentelemetry/api-logs": "^0.45.1",
     "@opentelemetry/core": "1.18.1",
-    "@opentelemetry/instrumentation": "^0.45.1"
+    "@opentelemetry/instrumentation": "^0.45.1",
+    "winston": "3.3.3",
+    "winston2": "npm:[email protected]"
   },
   "homepage": "https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-winston#readme"
 }

plugins/node/opentelemetry-instrumentation-winston/src/OpenTelemetryTransportv2.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright The 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
+ *
+ *      https://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.
+ */
+
+import { Logger, logs } from '@opentelemetry/api-logs';
+import * as winston from 'winston2';
+import { VERSION } from './version';
+import { emitLogRecord } from './utils';
+
+export class OpenTelemetryTransportv2 extends winston.Transport {
+  private _logger: Logger;
+
+  constructor(options: winston.TransportOptions) {
+    super(options);
+    this._logger = logs.getLogger(
+      '@opentelemetry/instrumentation-winston',
+      VERSION
+    );
+  }
+
+  log(level: string, msg: string, meta: any, callback: Function) {
+    try {
+      const logRecord: Record<string, any> = {
+        level: level,
+        msg: msg,
+        meta: meta,
+      };
+      emitLogRecord(logRecord, this._logger);
+      this.emit('logged');
+    } catch (error) {
+      this.emit('warn', error);
+    }
+    if (callback) {
+      callback(null, true);
+    }
+  }
+}

plugins/node/opentelemetry-instrumentation-winston/src/OpenTelemetryTransportv3.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright The 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
+ *
+ *      https://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.
+ */
+
+import { Logger, logs } from '@opentelemetry/api-logs';
+import * as Transport from 'winston-transport';
+import { VERSION } from './version';
+import { emitLogRecord } from './utils';
+
+export class OpenTelemetryTransportv3 extends Transport {
+  private _logger: Logger;
+
+  constructor(options: Transport.TransportStreamOptions) {
+    super(options);
+    this._logger = logs.getLogger(
+      '@opentelemetry/instrumentation-winston',
+      VERSION
+    );
+  }
+
+  public override log(info: any, next: () => void) {
+    try {
+      emitLogRecord(info, this._logger);
+      this.emit('logged', info);
+    } catch (error) {
+      this.emit('warn', error);
+    }
+    if (next) {
+      setImmediate(next);
+    }
+  }
+}

plugins/node/opentelemetry-instrumentation-winston/src/instrumentation.ts

@@ -21,13 +21,6 @@ import {
   Span,
   SpanContext,
 } from '@opentelemetry/api';
-import * as util from 'node:util';
-import {
-  LogRecord,
-  Logger,
-  SeverityNumber,
-  logs,
-} from '@opentelemetry/api-logs';
 import {
   InstrumentationBase,
   InstrumentationNodeModuleDefinition,
@@ -37,25 +30,23 @@ import {
 } from '@opentelemetry/instrumentation';
 import type { WinstonInstrumentationConfig } from './types';
 import type {
+  Winston2ConfigureMethod,
   Winston2LogMethod,
   Winston2LoggerModule,
+  Winston3ConfigureMethod,
   Winston3LogMethod,
   Winston3Logger,
 } from './internal-types';
 import { VERSION } from './version';
+import { OpenTelemetryTransportv3 } from './OpenTelemetryTransportv3';
+import { OpenTelemetryTransportv2 } from './OpenTelemetryTransportv2';
 
 const winston3Versions = ['>=3 <4'];
 const winstonPre3Versions = ['>=1 <3'];
 
 export class WinstonInstrumentation extends InstrumentationBase {
-  private _logger: Logger;
-
   constructor(config: WinstonInstrumentationConfig = {}) {
     super('@opentelemetry/instrumentation-winston', VERSION, config);
-    this._logger = logs.getLogger(
-      '@opentelemetry/instrumentation-winston',
-      VERSION
-    );
   }
 
   protected init() {
@@ -76,6 +67,12 @@ export class WinstonInstrumentation extends InstrumentationBase {
               }
               this._wrap(logger.prototype, 'write', this._getPatchedWrite());
 
+              // Wrap configure
+              if (isWrapped(logger.prototype['configure'])) {
+                this._unwrap(logger.prototype, 'configure');
+              }
+              this._wrap(logger.prototype, 'configure', this._getPatchedV3Configure());
+
               return logger;
             },
             (logger, moduleVersion) => {
@@ -104,6 +101,12 @@ export class WinstonInstrumentation extends InstrumentationBase {
               }
               this._wrap(proto, 'log', this._getPatchedLog());
 
+              // Wrap configure
+              if (isWrapped(proto.configure)) {
+                this._unwrap(proto, 'configure');
+              }
+              this._wrap(proto, 'configure', this._getPatchedV2Configure());
+
               return fileExports;
             },
             (fileExports, moduleVersion) => {
@@ -163,11 +166,6 @@ export class WinstonInstrumentation extends InstrumentationBase {
             }
           }
         }
-
-        if (!config.disableLogSending) {
-          instrumentation._emitLogRecord(record);
-        }
-
         return original.apply(this, args);
       };
     };
@@ -210,59 +208,63 @@ export class WinstonInstrumentation extends InstrumentationBase {
           }
         }
 
-        if (!config.disableLogSending) {
-          const logRecord: Record<string, any> = {};
-          if (args.length >= 1) {
-            // Level is always first argument
-            logRecord['level'] = args[0];
-
-            // Get meta if present
-            let metaIndex = 0;
-            for (let i = args.length - 1; i >= 0; i--) {
-              if (typeof args[i] === 'object') {
-                metaIndex = i;
-                logRecord['meta'] = args[metaIndex];
-                break;
-              }
-            }
-            const callback =
-              typeof args[args.length - 1] === 'function' ? 1 : 0;
-            // Arguments between level and meta or callbkack if present
-            const msgArguments = args.length - metaIndex - callback - 1;
+        return original.apply(this, args);
+      };
+    };
+  }
 
-            if (msgArguments > 0) {
-              if (msgArguments === 1) {
-                logRecord['msg'] = args[1];
-              } else {
-                // Handle string interpolation
-                const values = args.slice(2, msgArguments + 1);
-                logRecord['msg'] = util.format(args[1], ...values);
-              }
+  private _getPatchedV3Configure() {
+    return (original: Winston3ConfigureMethod) => {
+      const instrumentation = this;
+      return function patchedConfigure(
+        this: never,
+        ...args: Parameters<typeof original>
+      ) {
+        const config = instrumentation.getConfig();
+        if (!config.disableLogSending) {
+          if (args && args.length > 0) {
+            let originalTransports = args[0].transports;
+            let newTransports = Array.isArray(originalTransports)
+              ? originalTransports
+              : [];
+            const openTelemetryTransport = new OpenTelemetryTransportv3({});
+            if (originalTransports && !Array.isArray(originalTransports)) {
+              newTransports = [originalTransports];
             }
+            newTransports.push(openTelemetryTransport);
+            originalTransports = newTransports;
           }
-          instrumentation._emitLogRecord(logRecord);
         }
-
         return original.apply(this, args);
       };
     };
   }
 
-  private _emitLogRecord(record: Record<string, any>): void {
-    const { message, msg, level, meta, ...splat } = record;
-    const attributes = Object.assign(meta ?? {}, {});
-    for (const key in splat) {
-      if (Object.prototype.hasOwnProperty.call(splat, key)) {
-        attributes[key] = splat[key];
-      }
-    }
-    const logRecord: LogRecord = {
-      severityNumber: getSeverityNumber(level),
-      severityText: level,
-      body: message ?? msg,
-      attributes: attributes,
+  private _getPatchedV2Configure() {
+    return (original: Winston2ConfigureMethod) => {
+      const instrumentation = this;
+      return function patchedConfigure(
+        this: never,
+        ...args: Parameters<typeof original>
+      ) {
+        const config = instrumentation.getConfig();
+        if (!config.disableLogSending) {
+          if (args && args.length > 0) {
+            let originalTransports = args[0].transports;
+            let newTransports = Array.isArray(originalTransports)
+              ? originalTransports
+              : [];
+            const openTelemetryTransport = new OpenTelemetryTransportv2({});
+            if (originalTransports && !Array.isArray(originalTransports)) {
+              newTransports = [originalTransports];
+            }
+            newTransports.push(openTelemetryTransport);
+            originalTransports = newTransports;
+          }
+        }
+        return original.apply(this, args);
+      };
     };
-    this._logger.emit(logRecord);
   }
 }
 
@@ -282,41 +284,3 @@ function injectRecord(
 
   return Object.assign(record, fields);
 }
-
-const npmLevels: Record<string, number> = {
-  error: SeverityNumber.ERROR,
-  warn: SeverityNumber.WARN,
-  info: SeverityNumber.INFO,
-  http: SeverityNumber.DEBUG3,
-  verbose: SeverityNumber.DEBUG2,
-  debug: SeverityNumber.DEBUG,
-  silly: SeverityNumber.TRACE,
-};
-
-const sysLoglevels: Record<string, number> = {
-  emerg: SeverityNumber.FATAL3,
-  alert: SeverityNumber.FATAL2,
-  crit: SeverityNumber.FATAL,
-  error: SeverityNumber.ERROR,
-  warning: SeverityNumber.WARN,
-  notice: SeverityNumber.INFO2,
-  info: SeverityNumber.INFO,
-  debug: SeverityNumber.DEBUG,
-};
-
-const cliLevels: Record<string, number> = {
-  error: SeverityNumber.ERROR,
-  warn: SeverityNumber.WARN,
-  help: SeverityNumber.INFO3,
-  data: SeverityNumber.INFO2,
-  info: SeverityNumber.INFO,
-  debug: SeverityNumber.DEBUG,
-  prompt: SeverityNumber.TRACE4,
-  verbose: SeverityNumber.TRACE3,
-  input: SeverityNumber.TRACE2,
-  silly: SeverityNumber.TRACE,
-};
-
-function getSeverityNumber(level: string): SeverityNumber | undefined {
-  return npmLevels[level] ?? sysLoglevels[level] ?? cliLevels[level];
-}

plugins/node/opentelemetry-instrumentation-winston/src/internal-types.ts

@@ -14,16 +14,23 @@
  * limitations under the License.
  */
 
-import type { Logger as Winston3Logger } from 'winston';
+import type {
+  Logger as Winston3Logger,
+  LoggerOptions as Winstons3LoggerOptions,
+} from 'winston';
 import type {
   LoggerInstance as Winston2Logger,
   LogMethod as Winston2LogMethod,
 } from 'winston2';
 export type Winston3LogMethod = Winston3Logger['write'];
-export type { Winston3Logger };
+export type Winston3ConfigureMethod = Winston3Logger['configure'];
+export type { Winston3Logger, Winstons3LoggerOptions };
 
 export type { Winston2LogMethod };
+export type Winston2ConfigureMethod = Winston2Logger['configure'];
 export type Winston2LoggerModule = {
-  Logger: Winston2Logger & { prototype: { log: Winston2LogMethod } };
+  Logger: Winston2Logger & {
+    prototype: { log: Winston2LogMethod; configure: Winston2ConfigureMethod };
+  };
 };
 export type { Winston2Logger };