@ohos-ports/datadog-pprof 5.17.0-1

package/out/src/heap-profiler.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * 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
+ *
+ *      http://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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackMode = void 0;
+exports.v8Profile = v8Profile;
+exports.v8ProfileV2 = v8ProfileV2;
+exports.profile = profile;
+exports.convertProfile = convertProfile;
+exports.profileV2 = profileV2;
+exports.start = start;
+exports.stop = stop;
+exports.monitorOutOfMemory = monitorOutOfMemory;
+const heap_profiler_bindings_1 = require("./heap-profiler-bindings");
+const profile_serializer_1 = require("./profile-serializer");
+const worker_threads_1 = require("worker_threads");
+let enabled = false;
+let heapIntervalBytes = 0;
+let heapStackDepth = 0;
+let startedWithAllocations = false;
+/*
+ * Collects a heap profile when heapProfiler is enabled. Otherwise throws
+ * an error.
+ *
+ * Data is returned in V8 allocation profile format.
+ */
+function v8Profile() {
+    if (!enabled) {
+        throw new Error('Heap profiler is not enabled.');
+    }
+    return (0, heap_profiler_bindings_1.getAllocationProfile)();
+}
+/**
+ * Map the heap profile to a converted profile using callback function when
+ * heapProfiler is enabled. Otherwise throws an error.
+ *
+ * WARNING: Nodes in the tree are only valid during the callback. Do not store
+ * references to them. The memory is freed when the callback returns.
+ *
+ * @param callback - function to convert the heap profile to a converted
+  |file
+ * @returns <T> converted profile
+ */
+function v8ProfileV2(callback) {
+    if (!enabled) {
+        throw new Error('Heap profiler is not enabled.');
+    }
+    if (startedWithAllocations) {
+        throw new Error('profileV2 does not support allocation mode.');
+    }
+    return (0, heap_profiler_bindings_1.mapAllocationProfile)(callback);
+}
+/**
+ * Collects a profile and returns it serialized in pprof format.
+ * Throws if heap profiler is not enabled.
+ *
+ * @param ignoreSamplePath
+ * @param sourceMapper
+ */
+function profile(ignoreSamplePath, sourceMapper, generateLabels, columnNumbers = profile_serializer_1.DEFAULT_COLUMN_NUMBERS) {
+    const result = convertProfile(v8Profile(), ignoreSamplePath, sourceMapper, generateLabels, columnNumbers);
+    // In allocation mode V8 keeps every sampled object (live + collected-by-GC)
+    // in an append-only buffer that's only freed by stopSamplingHeapProfiler.
+    // Without this reset, each call to getAllocationProfile re-reads the entire
+    // history, so alloc_* totals grow linearly with wall-clock time and V8's
+    // internal sample buffer leaks for the lifetime of the process.
+    if (startedWithAllocations) {
+        (0, heap_profiler_bindings_1.stopSamplingHeapProfiler)();
+        (0, heap_profiler_bindings_1.startSamplingHeapProfiler)(heapIntervalBytes, heapStackDepth, true);
+    }
+    return result;
+}
+function convertProfile(rootNode, ignoreSamplePath, sourceMapper, generateLabels, columnNumbers = profile_serializer_1.DEFAULT_COLUMN_NUMBERS) {
+    const allocations = startedWithAllocations;
+    const startTimeNanos = Date.now() * 1000 * 1000;
+    // Add node for external memory usage.
+    // Current type definitions do not have external.
+    // TODO: remove any once type definition is updated to include external.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { external } = process.memoryUsage();
+    let root;
+    if (external > 0) {
+        if (allocations) {
+            const externalNode = {
+                name: '(external)',
+                scriptName: '',
+                children: [],
+                allocations: [
+                    {
+                        inuseObjects: 1,
+                        inuseSpaceBytes: external,
+                        allocObjects: 1,
+                        allocSpaceBytes: external,
+                    },
+                ],
+            };
+            const allocationRoot = rootNode;
+            root = {
+                ...allocationRoot,
+                children: [...allocationRoot.children, externalNode],
+            };
+        }
+        else {
+            const externalNode = {
+                name: '(external)',
+                scriptName: '',
+                children: [],
+                allocations: [{ sizeBytes: external, count: 1 }],
+            };
+            const heapRoot = rootNode;
+            root = { ...heapRoot, children: [...heapRoot.children, externalNode] };
+        }
+    }
+    else {
+        root = rootNode;
+    }
+    return (0, profile_serializer_1.serializeHeapProfile)(root, startTimeNanos, heapIntervalBytes, ignoreSamplePath, sourceMapper, generateLabels, allocations, columnNumbers);
+}
+/**
+ * Collects a profile and returns it serialized in pprof format using lazy V2 API.
+ * Throws if heap profiler is not enabled.
+ *
+ * @param ignoreSamplePath
+ * @param sourceMapper
+ * @param generateLabels
+ */
+function profileV2(ignoreSamplePath, sourceMapper, generateLabels, columnNumbers = profile_serializer_1.DEFAULT_COLUMN_NUMBERS) {
+    return v8ProfileV2(root => {
+        return convertProfile(root, ignoreSamplePath, sourceMapper, generateLabels, columnNumbers);
+    });
+}
+/**
+ * Starts heap profiling. If heap profiling has already been started with
+ * the same parameters, this is a noop. If heap profiler has already been
+ * started with different parameters, this throws an error.
+ *
+ * @param intervalBytes - average number of bytes between samples.
+ * @param stackDepth - maximum stack depth for samples collected.
+ * @param allocations - include total allocation samples in the profile.
+ *   When true, each call to `profile()` forces a full GC (via
+ *   v8::HeapProfiler::kSamplingForceGC) to classify sampled objects as
+ *   live/dead, which adds a measurable pause. Requires Node.js >= 26.
+ */
+function start(intervalBytes, stackDepth, allocations = false) {
+    if (enabled) {
+        throw new Error(`Heap profiler is already started  with intervalBytes ${heapIntervalBytes} and stackDepth ${stackDepth}`);
+    }
+    heapIntervalBytes = intervalBytes;
+    heapStackDepth = stackDepth;
+    startedWithAllocations = allocations;
+    (0, heap_profiler_bindings_1.startSamplingHeapProfiler)(intervalBytes, stackDepth, allocations);
+    enabled = true;
+}
+// Stops heap profiling. If heap profiling has not been started, does nothing.
+function stop() {
+    if (enabled) {
+        enabled = false;
+        startedWithAllocations = false;
+        (0, heap_profiler_bindings_1.stopSamplingHeapProfiler)();
+    }
+}
+exports.CallbackMode = {
+    Async: 1,
+    Interrupt: 2,
+    Both: 3,
+};
+/**
+ * Add monitoring for v8 heap, heap profiler must already be started.
+ * When an out of heap memory event occurs:
+ *  - an extension of heap memory of |heapLimitExtensionSize| bytes is
+ *    requested to v8. This extension can occur |maxHeapLimitExtensionCount|
+ *    number of times. If the extension amount is not enough to satisfy
+ *    memory allocation that triggers GC and OOM, process will abort.
+ *  - heap profile is dumped as folded stacks on stderr if
+ *    |dumpHeapProfileOnSdterr| is true
+ *  - heap profile is dumped in temporary file and a new process is spawned
+ *    with |exportCommand| arguments and profile path appended at the end.
+ *  - |callback| is called. Callback can be invoked only if
+ *    heapLimitExtensionSize is enough for the process to continue. Invocation
+ *    will be done by a RequestInterrupt if |callbackMode| is Interrupt or Both,
+ *    this might be unsafe since Isolate should not be reentered
+ *    from RequestInterrupt, but this allows to interrupt synchronous code.
+ *    Otherwise the callback is scheduled to be called asynchronously.
+ * @param heapLimitExtensionSize - amount of bytes heap should be expanded
+ *  with upon OOM
+ * @param maxHeapLimitExtensionCount - maximum number of times heap size
+ *  extension can occur
+ * @param dumpHeapProfileOnSdterr - dump heap profile on stderr upon OOM
+ * @param exportCommand - command to execute upon OOM, filepath of a
+ *  temporary file containing heap profile will be appended
+ * @param callback - callback to call when OOM occurs
+ * @param callbackMode
+ */
+function monitorOutOfMemory(heapLimitExtensionSize, maxHeapLimitExtensionCount, dumpHeapProfileOnSdterr, exportCommand, callback, callbackMode) {
+    if (!enabled) {
+        throw new Error('Heap profiler must already be started to call monitorOutOfMemory');
+    }
+    let newCallback;
+    if (typeof callback !== 'undefined') {
+        newCallback = (profile) => {
+            callback(convertProfile(profile));
+        };
+    }
+    (0, heap_profiler_bindings_1.monitorOutOfMemory)(heapLimitExtensionSize, maxHeapLimitExtensionCount, dumpHeapProfileOnSdterr, exportCommand || [], newCallback, typeof callbackMode !== 'undefined' ? callbackMode : exports.CallbackMode.Async, worker_threads_1.isMainThread);
+}
+//# sourceMappingURL=heap-profiler.js.map

package/out/src/heap-profiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-profiler.js","sourceRoot":"","sources":["../../ts/src/heap-profiler.ts"],"names":[],"mappings":"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"}

package/out/src/index.d.ts

@@ -0,0 +1,46 @@
+import * as heapProfiler from './heap-profiler';
+import * as otelThreadCtxModule from './otel-thread-ctx';
+import * as timeProfiler from './time-profiler';
+export { AllocationProfileNode, TimeProfileNode, ProfileNode, LabelSet, } from './v8-types';
+export { encode, encodeSync } from './profile-encoder';
+export { SourceMapper } from './sourcemapper/sourcemapper';
+export { setLogger } from './logger';
+export { getNativeThreadId } from './time-profiler';
+export declare const time: {
+    profile: typeof timeProfiler.profile;
+    start: typeof timeProfiler.start;
+    stop: typeof timeProfiler.stop;
+    profileV2: typeof timeProfiler.profileV2;
+    getContext: typeof timeProfiler.getContext;
+    setContext: typeof timeProfiler.setContext;
+    runWithContext: typeof timeProfiler.runWithContext;
+    isStarted: typeof timeProfiler.isStarted;
+    v8ProfilerStuckEventLoopDetected: typeof timeProfiler.v8ProfilerStuckEventLoopDetected;
+    getState: typeof timeProfiler.getState;
+    getMetrics: typeof timeProfiler.getMetrics;
+    constants: {
+        kSampleCount: any;
+        GARBAGE_COLLECTION_FUNCTION_NAME: string;
+        NON_JS_THREADS_FUNCTION_NAME: string;
+    };
+};
+export declare const heap: {
+    start: typeof heapProfiler.start;
+    stop: typeof heapProfiler.stop;
+    profile: typeof heapProfiler.profile;
+    profileV2: typeof heapProfiler.profileV2;
+    convertProfile: typeof heapProfiler.convertProfile;
+    v8Profile: typeof heapProfiler.v8Profile;
+    monitorOutOfMemory: typeof heapProfiler.monitorOutOfMemory;
+    CallbackMode: {
+        Async: number;
+        Interrupt: number;
+        Both: number;
+    };
+};
+export declare const otelThreadCtx: {
+    ThreadContext: otelThreadCtxModule.ThreadContextCtor;
+    getContext: () => otelThreadCtxModule.ThreadContext | undefined;
+    clearContext: () => void;
+    getProcessContextAttributes: typeof otelThreadCtxModule.getProcessContextAttributes;
+};

package/out/src/index.js

@@ -0,0 +1,111 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.otelThreadCtx = exports.heap = exports.time = exports.getNativeThreadId = exports.setLogger = exports.SourceMapper = exports.encodeSync = exports.encode = void 0;
+/**
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * 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
+ *
+ *      http://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.
+ */
+const fs_1 = require("fs");
+const heapProfiler = __importStar(require("./heap-profiler"));
+const otelThreadCtxModule = __importStar(require("./otel-thread-ctx"));
+const profile_encoder_1 = require("./profile-encoder");
+const timeProfiler = __importStar(require("./time-profiler"));
+var profile_encoder_2 = require("./profile-encoder");
+Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return profile_encoder_2.encode; } });
+Object.defineProperty(exports, "encodeSync", { enumerable: true, get: function () { return profile_encoder_2.encodeSync; } });
+var sourcemapper_1 = require("./sourcemapper/sourcemapper");
+Object.defineProperty(exports, "SourceMapper", { enumerable: true, get: function () { return sourcemapper_1.SourceMapper; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_1.setLogger; } });
+var time_profiler_1 = require("./time-profiler");
+Object.defineProperty(exports, "getNativeThreadId", { enumerable: true, get: function () { return time_profiler_1.getNativeThreadId; } });
+exports.time = {
+    profile: timeProfiler.profile,
+    start: timeProfiler.start,
+    stop: timeProfiler.stop,
+    profileV2: timeProfiler.profileV2,
+    getContext: timeProfiler.getContext,
+    setContext: timeProfiler.setContext,
+    runWithContext: timeProfiler.runWithContext,
+    isStarted: timeProfiler.isStarted,
+    v8ProfilerStuckEventLoopDetected: timeProfiler.v8ProfilerStuckEventLoopDetected,
+    getState: timeProfiler.getState,
+    getMetrics: timeProfiler.getMetrics,
+    constants: timeProfiler.constants,
+};
+exports.heap = {
+    start: heapProfiler.start,
+    stop: heapProfiler.stop,
+    profile: heapProfiler.profile,
+    profileV2: heapProfiler.profileV2,
+    convertProfile: heapProfiler.convertProfile,
+    v8Profile: heapProfiler.v8Profile,
+    monitorOutOfMemory: heapProfiler.monitorOutOfMemory,
+    CallbackMode: heapProfiler.CallbackMode,
+};
+// Writer for the OpenTelemetry Thread Local Context Record (OTEP-4947).
+// Linux + AsyncContextFrame (Node 22 with --experimental-async-context-frame,
+// Node 24+ by default) only; degrades to no-ops on other platforms / Node
+// versions.
+exports.otelThreadCtx = {
+    ThreadContext: otelThreadCtxModule.ThreadContext,
+    getContext: otelThreadCtxModule.getContext,
+    clearContext: otelThreadCtxModule.clearContext,
+    getProcessContextAttributes: otelThreadCtxModule.getProcessContextAttributes,
+};
+// If loaded with --require, start profiling.
+if (module.parent && module.parent.id === 'internal/preload') {
+    exports.time.start({});
+    process.on('exit', () => {
+        // The process is going to terminate imminently. All work here needs to
+        // be synchronous.
+        const profile = exports.time.stop();
+        const buffer = (0, profile_encoder_1.encodeSync)(profile);
+        (0, fs_1.writeFileSync)(`pprof-profile-${process.pid}.pb.gz`, buffer);
+    });
+}
+//# sourceMappingURL=index.js.map

package/out/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;GAcG;AACH,2BAAiC;AAEjC,8DAAgD;AAChD,uEAAyD;AACzD,uDAA6C;AAC7C,8DAAgD;AAQhD,qDAAqD;AAA7C,yGAAA,MAAM,OAAA;AAAE,6GAAA,UAAU,OAAA;AAC1B,4DAAyD;AAAjD,4GAAA,YAAY,OAAA;AACpB,mCAAmC;AAA3B,mGAAA,SAAS,OAAA;AACjB,iDAAkD;AAA1C,kHAAA,iBAAiB,OAAA;AAEZ,QAAA,IAAI,GAAG;IAClB,OAAO,EAAE,YAAY,CAAC,OAAO;IAC7B,KAAK,EAAE,YAAY,CAAC,KAAK;IACzB,IAAI,EAAE,YAAY,CAAC,IAAI;IACvB,SAAS,EAAE,YAAY,CAAC,SAAS;IACjC,UAAU,EAAE,YAAY,CAAC,UAAU;IACnC,UAAU,EAAE,YAAY,CAAC,UAAU;IACnC,cAAc,EAAE,YAAY,CAAC,cAAc;IAC3C,SAAS,EAAE,YAAY,CAAC,SAAS;IACjC,gCAAgC,EAC9B,YAAY,CAAC,gCAAgC;IAC/C,QAAQ,EAAE,YAAY,CAAC,QAAQ;IAC/B,UAAU,EAAE,YAAY,CAAC,UAAU;IACnC,SAAS,EAAE,YAAY,CAAC,SAAS;CAClC,CAAC;AAEW,QAAA,IAAI,GAAG;IAClB,KAAK,EAAE,YAAY,CAAC,KAAK;IACzB,IAAI,EAAE,YAAY,CAAC,IAAI;IACvB,OAAO,EAAE,YAAY,CAAC,OAAO;IAC7B,SAAS,EAAE,YAAY,CAAC,SAAS;IACjC,cAAc,EAAE,YAAY,CAAC,cAAc;IAC3C,SAAS,EAAE,YAAY,CAAC,SAAS;IACjC,kBAAkB,EAAE,YAAY,CAAC,kBAAkB;IACnD,YAAY,EAAE,YAAY,CAAC,YAAY;CACxC,CAAC;AAEF,wEAAwE;AACxE,8EAA8E;AAC9E,0EAA0E;AAC1E,YAAY;AACC,QAAA,aAAa,GAAG;IAC3B,aAAa,EAAE,mBAAmB,CAAC,aAAa;IAChD,UAAU,EAAE,mBAAmB,CAAC,UAAU;IAC1C,YAAY,EAAE,mBAAmB,CAAC,YAAY;IAC9C,2BAA2B,EAAE,mBAAmB,CAAC,2BAA2B;CAC7E,CAAC;AAEF,6CAA6C;AAC7C,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,kBAAkB,EAAE,CAAC;IAC7D,YAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACf,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;QACtB,uEAAuE;QACvE,kBAAkB;QAClB,MAAM,OAAO,GAAG,YAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAA,4BAAU,EAAC,OAAO,CAAC,CAAC;QACnC,IAAA,kBAAa,EAAC,iBAAiB,OAAO,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;AACL,CAAC"}

package/out/src/logger.d.ts

@@ -0,0 +1,18 @@
+export interface Logger {
+    error(...args: Array<{}>): void;
+    trace(...args: Array<{}>): void;
+    debug(...args: Array<{}>): void;
+    info(...args: Array<{}>): void;
+    warn(...args: Array<{}>): void;
+    fatal(...args: Array<{}>): void;
+}
+export declare class NullLogger implements Logger {
+    info(...args: Array<{}>): void;
+    error(...args: Array<{}>): void;
+    trace(...args: Array<{}>): void;
+    warn(...args: Array<{}>): void;
+    fatal(...args: Array<{}>): void;
+    debug(...args: Array<{}>): void;
+}
+export declare let logger: NullLogger;
+export declare function setLogger(newLogger: Logger): void;

package/out/src/logger.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.NullLogger = void 0;
+exports.setLogger = setLogger;
+class NullLogger {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    info(...args) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    error(...args) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    trace(...args) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    warn(...args) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fatal(...args) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    debug(...args) {
+        return;
+    }
+}
+exports.NullLogger = NullLogger;
+exports.logger = new NullLogger();
+function setLogger(newLogger) {
+    exports.logger = newLogger;
+}
+//# sourceMappingURL=logger.js.map

package/out/src/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../ts/src/logger.ts"],"names":[],"mappings":";;;AAsCA,8BAEC;AA/BD,MAAa,UAAU;IACrB,6DAA6D;IAC7D,IAAI,CAAC,GAAG,IAAe;QACrB,OAAO;IACT,CAAC;IACD,6DAA6D;IAC7D,KAAK,CAAC,GAAG,IAAe;QACtB,OAAO;IACT,CAAC;IACD,6DAA6D;IAC7D,KAAK,CAAC,GAAG,IAAe;QACtB,OAAO;IACT,CAAC;IACD,6DAA6D;IAC7D,IAAI,CAAC,GAAG,IAAe;QACrB,OAAO;IACT,CAAC;IACD,6DAA6D;IAC7D,KAAK,CAAC,GAAG,IAAe;QACtB,OAAO;IACT,CAAC;IACD,6DAA6D;IAC7D,KAAK,CAAC,GAAG,IAAe;QACtB,OAAO;IACT,CAAC;CACF;AAzBD,gCAyBC;AAEU,QAAA,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;AAErC,SAAgB,SAAS,CAAC,SAAiB;IACzC,cAAM,GAAG,SAAS,CAAC;AACrB,CAAC"}

package/out/src/otel-thread-ctx.d.ts

@@ -0,0 +1,85 @@
+/**
+ * OTEP-4719 process-context attributes corresponding to a particular
+ * key list. Spread this into whatever attribute map the application
+ * hands to its OTEP-4719 process-context publisher.
+ */
+export interface ProcessContextAttributes {
+    readonly 'threadlocal.schema_version': 'nodejs_v1_dev';
+    readonly 'threadlocal.attribute_key_map': readonly string[];
+    readonly 'threadlocal.wrapped_object_offset': number;
+    readonly 'threadlocal.tagged_size': number;
+    readonly 'threadlocal.native_wrap_fields_offset': number;
+    readonly 'threadlocal.js_map_table_offset': number;
+    readonly 'threadlocal.ordered_hash_map_header_size': number;
+}
+/**
+ * A thread-context record. Construct with `new ThreadContext(...)`; install
+ * via the {@link enter} or {@link run} instance methods. The underlying
+ * native record is GC-owned: when no JS or async-context-frame reference
+ * survives, it's freed.
+ *
+ * `appendAttributes` mutates the context's record in place. Because every
+ * async-context frame that holds the same `ThreadContext` reference observes
+ * the same native record buffer, an append is visible across all those
+ * frames even when the reallocate path runs (the context's internal
+ * pointer is updated, the JS object is not replaced).
+ */
+export interface ThreadContext {
+    appendAttributes(attributes: Array<string | null | undefined> | undefined): void;
+    isTruncated(): boolean;
+    /** Debug-only: returns the on-the-wire record bytes. Not stable. */
+    debugBytes(): Uint8Array;
+    /**
+     * Attach this context to the current async-context frame (and every
+     * frame derived from it until the frame ends or {@link clearContext}
+     * detaches it). Re-installing the same context reference is cheap (no
+     * allocation); per-span caching of the context on the caller side is
+     * the intended usage pattern.
+     *
+     * On non-Linux platforms this is a no-op.
+     */
+    enter(): void;
+    /**
+     * Attach this context for the duration of `fn`. Equivalent to
+     * `als.run(this, fn)` — after `fn` returns, the previous context is
+     * restored. Returns whatever `fn` returns; if `fn` returns a Promise,
+     * the same Promise is propagated. On non-Linux platforms simply
+     * invokes `fn`.
+     */
+    run<T>(fn: () => T): T;
+}
+/**
+ * Constructor for {@link ThreadContext}. On non-Linux platforms, returns a
+ * no-op instance whose methods do nothing — the OTEP-4947 reader
+ * contract is ELF-TLSDESC, only meaningful on Linux.
+ */
+export interface ThreadContextCtor {
+    new (traceId: Uint8Array, spanId: Uint8Array, attributes?: Array<string | null | undefined>): ThreadContext;
+    readonly prototype: ThreadContext;
+}
+/** {@inheritDoc ThreadContextCtor} */
+export declare let ThreadContext: ThreadContextCtor;
+/**
+ * Returns the {@link ThreadContext} currently attached to the active
+ * async-context frame, or `undefined` if none is.
+ */
+export declare let getContext: () => ThreadContext | undefined;
+/**
+ * Detach any {@link ThreadContext} from the current async-context frame.
+ * Idempotent when no context is attached. On non-Linux platforms this is
+ * a no-op.
+ */
+export declare let clearContext: () => void;
+export declare let _currentRecordBytes: () => Uint8Array | undefined;
+/**
+ * Returns the OTEP-4719 process-context attributes the caller should
+ * publish so an out-of-process reader can decode the on-the-wire uint8
+ * key indexes back to attribute names. The supplied `keys` array is the
+ * same string list the caller writes into the positional `attributes`
+ * argument of {@link ThreadContext}: index N here is the uint8 key index
+ * N in each record.
+ *
+ * `keys` is validated: must be a string array of length ≤ 256 with no
+ * duplicates.
+ */
+export declare function getProcessContextAttributes(keys: string[]): ProcessContextAttributes;