@crawlee/otel 4.0.0-beta.210 → 4.0.0-beta.212

package/instrumentation.d.ts

@@ -3,6 +3,7 @@ import type { InstrumentationModuleDefinition } from '@opentelemetry/instrumenta
 import { InstrumentationBase } from '@opentelemetry/instrumentation';
 import type { CrawleeInstrumentationConfig } from './types.js';
 export declare class CrawleeInstrumentation extends InstrumentationBase<CrawleeInstrumentationConfig> {
+    #private;
     constructor(config?: CrawleeInstrumentationConfig);
     /**
      * Shares the tracer with the exported `wrapWithSpan` helper, so that manually wrapped handlers end up in the same
@@ -17,21 +18,4 @@ export declare class CrawleeInstrumentation extends InstrumentationBase<CrawleeI
     setTracerProvider(tracerProvider: TracerProvider): void;
     protected init(): InstrumentationModuleDefinition[];
     private instantiateModuleDefinitions;
-    /**
-     * Resolves the prototype holding the method to patch, warning instead of throwing when the class or the method
-     * is not there - a missing internal method must not break loading of the instrumented module.
-     */
-    private getPrototype;
-    /** Mirrors {@link getPrototype}: only methods that were actually patched are restored. */
-    private unwrapIfWrapped;
-    private applyClassMethodPatch;
-    private getLogPatch;
-    /**
-     * Emits one Crawlee log call as an OpenTelemetry log record.
-     *
-     * Everything here - reading the arguments, stringifying the message, handing the record to the SDK - runs inside
-     * the application's own call to `log.info()` and friends, so a failure anywhere in it is reported and dropped
-     * rather than raised.
-     */
-    private forwardLogRecord;
 }

package/instrumentation.js

@@ -54,34 +54,35 @@ export class CrawleeInstrumentation extends InstrumentationBase {
         if (this.getConfig().logInstrumentation) {
             definitions.push(crawleeModuleDefinition('@crawlee/core', (moduleExports) => {
                 for (const method of loggerMethods) {
-                    const prototype = this.getPrototype(moduleExports, '@crawlee/core', 'BaseCrawleeLogger', method.methodName);
+                    const prototype = this.#getPrototype(moduleExports, '@crawlee/core', 'BaseCrawleeLogger', method.methodName);
                     if (prototype) {
-                        this._wrap(prototype, method.methodName, this.getLogPatch(method));
+                        this._wrap(prototype, method.methodName, this.#getLogPatch(method));
                     }
                 }
                 return moduleExports;
             }, (moduleExports) => {
                 for (const method of loggerMethods) {
-                    this.unwrapIfWrapped(moduleExports?.BaseCrawleeLogger?.prototype, method.methodName);
+                    this.#unwrapIfWrapped(moduleExports?.BaseCrawleeLogger?.prototype, method.methodName);
                 }
                 return moduleExports;
             }));
         }
         return definitions;
     }
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- `InstrumentationBase`'s constructor calls `init()` before `#` members exist
     instantiateModuleDefinitions(moduleDefinitions) {
         return moduleDefinitions.map((definition) => {
             return crawleeModuleDefinition(definition.moduleName, (moduleExports) => {
                 for (const patch of definition.classMethodPatches) {
-                    const prototype = this.getPrototype(moduleExports, definition.moduleName, patch.className, patch.methodName);
+                    const prototype = this.#getPrototype(moduleExports, definition.moduleName, patch.className, patch.methodName);
                     if (prototype) {
-                        this._wrap(prototype, patch.methodName, this.applyClassMethodPatch(patch));
+                        this._wrap(prototype, patch.methodName, this.#applyClassMethodPatch(patch));
                     }
                 }
                 return moduleExports;
             }, (moduleExports) => {
                 for (const patch of definition.classMethodPatches) {
-                    this.unwrapIfWrapped(moduleExports?.[patch.className]?.prototype, patch.methodName);
+                    this.#unwrapIfWrapped(moduleExports?.[patch.className]?.prototype, patch.methodName);
                 }
                 return moduleExports;
             });
@@ -91,7 +92,7 @@ export class CrawleeInstrumentation extends InstrumentationBase {
      * Resolves the prototype holding the method to patch, warning instead of throwing when the class or the method
      * is not there - a missing internal method must not break loading of the instrumented module.
      */
-    getPrototype(moduleExports, moduleName, className, methodName) {
+    #getPrototype(moduleExports, moduleName, className, methodName) {
         const prototype = moduleExports?.[className]?.prototype;
         if (typeof prototype?.[methodName] !== 'function') {
             this._diag.warn(`Skipping instrumentation of ${moduleName}: ${className}.${methodName} was not found. ` +
@@ -100,13 +101,13 @@ export class CrawleeInstrumentation extends InstrumentationBase {
         }
         return prototype;
     }
-    /** Mirrors {@link getPrototype}: only methods that were actually patched are restored. */
-    unwrapIfWrapped(prototype, methodName) {
+    /** Mirrors `#getPrototype`: only methods that were actually patched are restored. */
+    #unwrapIfWrapped(prototype, methodName) {
         if (prototype && isWrapped(prototype[methodName])) {
             this._unwrap(prototype, methodName);
         }
     }
-    applyClassMethodPatch(patch) {
+    #applyClassMethodPatch(patch) {
         const { spanName, spanOptions } = patch;
         const qualifiedName = `${patch.className}.${patch.methodName}`;
         const codeAttributes = { [ATTR_CODE_FUNCTION_NAME]: qualifiedName };
@@ -124,7 +125,7 @@ export class CrawleeInstrumentation extends InstrumentationBase {
             });
         };
     }
-    getLogPatch(method) {
+    #getLogPatch(method) {
         // oxlint-disable-next-line no-this-alias
         const instrumentation = this;
         return function wrapLog(original) {
@@ -136,7 +137,7 @@ export class CrawleeInstrumentation extends InstrumentationBase {
                     original.apply(this, args);
                 }
                 finally {
-                    instrumentation.forwardLogRecord(method, args);
+                    instrumentation.#forwardLogRecord(method, args);
                 }
             };
         };
@@ -148,7 +149,7 @@ export class CrawleeInstrumentation extends InstrumentationBase {
      * the application's own call to `log.info()` and friends, so a failure anywhere in it is reported and dropped
      * rather than raised.
      */
-    forwardLogRecord(method, args) {
+    #forwardLogRecord(method, args) {
         try {
             const { message, data } = method.read(args);
             // Crawlee leaves level filtering to the logging library, so everything is forwarded and the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/otel",
-    "version": "4.0.0-beta.210",
+    "version": "4.0.0-beta.212",
     "description": "OpenTelemetry instrumentation for Crawlee",
     "engines": {
         "node": ">=22.0.0"
@@ -60,5 +60,5 @@
             }
         }
     },
-    "gitHead": "037dff5d651d88e96749cc79d17bc6d1e154f4e1"
+    "gitHead": "171a63a5d7f2a6d74cbce58479204ac20d30b87e"
 }