@dagger.io/dagger 0.13.2 → 0.13.4

package/dist/provisioning/bin.js

@@ -0,0 +1,353 @@
+import AdmZip from "adm-zip";
+import * as crypto from "crypto";
+import envPaths from "env-paths";
+import { execa } from "execa";
+import * as fs from "fs";
+import fetch from "node-fetch";
+import * as os from "os";
+import * as path from "path";
+import * as process from "process";
+import readline from "readline";
+import * as tar from "tar";
+import { fileURLToPath } from "url";
+import { EngineSessionConnectionTimeoutError, EngineSessionConnectParamsParseError, EngineSessionError, InitEngineSessionBinaryError, } from "../common/errors/index.js";
+import { createGQLClient } from "../graphql/client.js";
+const CLI_HOST = "dl.dagger.io";
+let OVERRIDE_CLI_URL;
+let OVERRIDE_CHECKSUMS_URL;
+/**
+ * Bin runs an engine session from a specified binary
+ */
+export class Bin {
+    _subProcess;
+    binPath;
+    cliVersion;
+    cacheDir = path.join(`${process.env.XDG_CACHE_HOME?.trim() || envPaths("", { suffix: "" }).cache}`, "dagger");
+    DAGGER_CLI_BIN_PREFIX = "dagger";
+    constructor(binPath, cliVersion) {
+        this.binPath = binPath;
+        this.cliVersion = cliVersion;
+    }
+    Addr() {
+        return "http://dagger";
+    }
+    get subProcess() {
+        return this._subProcess;
+    }
+    async Connect(opts) {
+        if (!this.binPath) {
+            if (opts.LogOutput) {
+                opts.LogOutput.write("Downloading CLI... ");
+            }
+            this.binPath = await this.downloadCLI();
+            if (opts.LogOutput) {
+                opts.LogOutput.write("OK!\n");
+            }
+        }
+        return this.runEngineSession(this.binPath, opts);
+    }
+    async downloadCLI() {
+        if (!this.cliVersion) {
+            throw new Error("cliVersion is not set");
+        }
+        const binPath = this.buildBinPath();
+        // Create a temporary bin file path
+        this.createCacheDir();
+        const tmpBinDownloadDir = fs.mkdtempSync(path.join(this.cacheDir, `temp-${this.getRandomId()}`));
+        const tmpBinPath = this.buildOsExePath(tmpBinDownloadDir, this.DAGGER_CLI_BIN_PREFIX);
+        try {
+            // download an archive and use appropriate extraction depending on platforms (zip on windows, tar.gz on other platforms)
+            const actualChecksum = await this.extractArchive(tmpBinDownloadDir, this.normalizedOS());
+            const expectedChecksum = await this.expectedChecksum();
+            if (actualChecksum !== expectedChecksum) {
+                throw new Error(`checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`);
+            }
+            fs.chmodSync(tmpBinPath, 0o700);
+            fs.renameSync(tmpBinPath, binPath);
+            fs.rmSync(tmpBinDownloadDir, { recursive: true });
+        }
+        catch (e) {
+            fs.rmSync(tmpBinDownloadDir, { recursive: true });
+            throw new InitEngineSessionBinaryError(`failed to download dagger cli binary: ${e}`, {
+                cause: e,
+            });
+        }
+        // Remove all temporary binary files
+        // Ignore current dagger cli or other files that have not be
+        // created by this SDK.
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            files.forEach((file) => {
+                const filePath = path.join(this.cacheDir, file);
+                if (filePath === binPath ||
+                    !file.startsWith(this.DAGGER_CLI_BIN_PREFIX)) {
+                    return;
+                }
+                fs.unlinkSync(filePath);
+            });
+        }
+        catch {
+            // Log the error but do not interrupt program.
+            console.error("could not clean up temporary binary files");
+        }
+        return binPath;
+    }
+    /**
+     * Traverse up the directory tree to find the package.json file and return the
+     * SDK version.
+     * @returns the SDK version or "n/a" if the version cannot be found.
+     */
+    getSDKVersion() {
+        const currentFileUrl = import.meta.url;
+        const currentFilePath = fileURLToPath(currentFileUrl);
+        let currentPath = path.dirname(currentFilePath);
+        while (currentPath !== path.parse(currentPath).root) {
+            const packageJsonPath = path.join(currentPath, "package.json");
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");
+                    const packageJson = JSON.parse(packageJsonContent);
+                    return packageJson.version;
+                }
+                catch {
+                    return "n/a";
+                }
+            }
+            else {
+                currentPath = path.join(currentPath, "..");
+            }
+        }
+    }
+    /**
+     * runEngineSession execute the engine binary and set up a GraphQL client that
+     * target this engine.
+     */
+    async runEngineSession(binPath, opts) {
+        const args = ["session"];
+        const sdkVersion = this.getSDKVersion();
+        const flagsAndValues = [
+            { flag: "--workdir", value: opts.Workdir },
+            { flag: "--project", value: opts.Project },
+            { flag: "--label", value: "dagger.io/sdk.name:nodejs" },
+            { flag: "--label", value: `dagger.io/sdk.version:${sdkVersion}` },
+        ];
+        flagsAndValues.forEach((pair) => {
+            if (pair.value) {
+                args.push(pair.flag, pair.value);
+            }
+        });
+        if (opts.LogOutput) {
+            opts.LogOutput.write("Creating new Engine session... ");
+        }
+        this._subProcess = execa(binPath, args, {
+            stdio: "pipe",
+            reject: true,
+            // Kill the process if parent exit.
+            cleanup: true,
+            // Set a long timeout to give time for any cache exports to pack layers up
+            // which currently has to happen synchronously with the session.
+            forceKillAfterDelay: 300000,
+        });
+        // Log the output if the user wants to.
+        if (opts.LogOutput) {
+            this._subProcess.stderr?.pipe(opts.LogOutput);
+        }
+        const stdoutReader = readline.createInterface({
+            input: this._subProcess?.stdout,
+        });
+        const timeOutDuration = 300000;
+        if (opts.LogOutput) {
+            opts.LogOutput.write("OK!\nEstablishing connection to Engine... ");
+        }
+        const connectParams = (await Promise.race([
+            this.readConnectParams(stdoutReader),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new EngineSessionConnectionTimeoutError("Engine connection timeout", {
+                        timeOutDuration,
+                    }));
+                }, timeOutDuration).unref(); // long timeout to account for extensions, though that should be optimized in future
+            }),
+        ]));
+        if (opts.LogOutput) {
+            opts.LogOutput.write("OK!\n");
+        }
+        return createGQLClient(connectParams.port, connectParams.session_token);
+    }
+    async readConnectParams(stdoutReader) {
+        for await (const line of stdoutReader) {
+            // parse the line as json-encoded connect params
+            const connectParams = JSON.parse(line);
+            if (connectParams.port && connectParams.session_token) {
+                return connectParams;
+            }
+            throw new EngineSessionConnectParamsParseError(`invalid connect params: ${line}`, {
+                parsedLine: line,
+            });
+        }
+        // Need to find a better way to handle this part
+        // At this stage something wrong happened, `for await` didn't return anything
+        // await the subprocess to catch the error
+        try {
+            await this.subProcess;
+        }
+        catch {
+            this.subProcess?.catch((e) => {
+                throw new EngineSessionError(e.stderr);
+            });
+        }
+    }
+    async Close() {
+        if (this.subProcess?.pid) {
+            this.subProcess.kill("SIGTERM");
+        }
+    }
+    /**
+     * createCacheDir will create a cache directory on user
+     * host to store dagger binary.
+     *
+     * If set, it will use envPaths to determine system's cache directory,
+     * if not, it will use `$HOME/.cache` as base path.
+     * Nothing happens if the directory already exists.
+     */
+    createCacheDir() {
+        fs.mkdirSync(this.cacheDir, { mode: 0o700, recursive: true });
+    }
+    /**
+     * buildBinPath create a path to output dagger cli binary.
+     *
+     * It will store it in the cache directory with a name composed
+     * of the base engine session as constant and the engine identifier.
+     */
+    buildBinPath() {
+        return this.buildOsExePath(this.cacheDir, `${this.DAGGER_CLI_BIN_PREFIX}-${this.cliVersion}`);
+    }
+    /**
+     * buildExePath create a path to output dagger cli binary.
+     */
+    buildOsExePath(destinationDir, filename) {
+        const binPath = path.join(destinationDir, filename);
+        switch (this.normalizedOS()) {
+            case "windows":
+                return `${binPath}.exe`;
+            default:
+                return binPath;
+        }
+    }
+    /**
+     * normalizedArch returns the architecture name used by the rest of our SDKs.
+     */
+    normalizedArch() {
+        switch (os.arch()) {
+            case "x64":
+                return "amd64";
+            default:
+                return os.arch();
+        }
+    }
+    /**
+     * normalizedOS returns the os name used by the rest of our SDKs.
+     */
+    normalizedOS() {
+        switch (os.platform()) {
+            case "win32":
+                return "windows";
+            default:
+                return os.platform();
+        }
+    }
+    cliArchiveName() {
+        if (OVERRIDE_CLI_URL) {
+            return path.basename(new URL(OVERRIDE_CLI_URL).pathname);
+        }
+        let ext = "tar.gz";
+        if (this.normalizedOS() === "windows") {
+            ext = "zip";
+        }
+        return `dagger_v${this.cliVersion}_${this.normalizedOS()}_${this.normalizedArch()}.${ext}`;
+    }
+    cliArchiveURL() {
+        if (OVERRIDE_CLI_URL) {
+            return OVERRIDE_CLI_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/${this.cliArchiveName()}`;
+    }
+    cliChecksumURL() {
+        if (OVERRIDE_CHECKSUMS_URL) {
+            return OVERRIDE_CHECKSUMS_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/checksums.txt`;
+    }
+    async checksumMap() {
+        // download checksums.txt
+        const checksums = await fetch(this.cliChecksumURL());
+        if (!checksums.ok) {
+            throw new Error(`failed to download checksums.txt from ${this.cliChecksumURL()}`);
+        }
+        const checksumsText = await checksums.text();
+        // iterate over lines filling in map of filename -> checksum
+        const checksumMap = new Map();
+        for (const line of checksumsText.split("\n")) {
+            const [checksum, filename] = line.split(/\s+/);
+            checksumMap.set(filename, checksum);
+        }
+        return checksumMap;
+    }
+    async expectedChecksum() {
+        const checksumMap = await this.checksumMap();
+        const expectedChecksum = checksumMap.get(this.cliArchiveName());
+        if (!expectedChecksum) {
+            throw new Error(`failed to find checksum for ${this.cliArchiveName()} in checksums.txt`);
+        }
+        return expectedChecksum;
+    }
+    async extractArchive(destDir, os) {
+        // extract the dagger binary in the cli archive and return the archive of the .zip for windows and .tar.gz for other plateforms
+        const archiveResp = await fetch(this.cliArchiveURL());
+        if (!archiveResp.ok) {
+            throw new Error(`failed to download dagger cli archive from ${this.cliArchiveURL()}`);
+        }
+        if (!archiveResp.body) {
+            throw new Error("archive response body is null");
+        }
+        // create a temporary file to store the archive
+        const archivePath = path.join(destDir, os === "windows" ? "dagger.zip" : "dagger.tar.gz");
+        const archiveFile = fs.createWriteStream(archivePath);
+        await new Promise((resolve, reject) => {
+            archiveResp.body?.pipe(archiveFile);
+            archiveResp.body?.on("error", reject);
+            archiveFile.on("finish", resolve);
+        });
+        const actualChecksum = crypto
+            .createHash("sha256")
+            .update(fs.readFileSync(archivePath))
+            .digest("hex");
+        if (os === "windows") {
+            const zip = new AdmZip(archivePath);
+            // extract just dagger.exe to the destdir
+            zip.extractEntryTo("dagger.exe", destDir, false, true);
+        }
+        else {
+            tar.extract({
+                cwd: destDir,
+                file: archivePath,
+                sync: true,
+            });
+        }
+        return actualChecksum;
+    }
+    /**
+     * Generate a unix timestamp in nanosecond
+     */
+    getRandomId() {
+        return process.hrtime.bigint().toString();
+    }
+}
+// Only meant for tests
+export function _overrideCLIURL(url) {
+    OVERRIDE_CLI_URL = url;
+}
+// Only meant for tests
+export function _overrideCLIChecksumsURL(url) {
+    OVERRIDE_CHECKSUMS_URL = url;
+}

package/dist/provisioning/default.d.ts

@@ -0,0 +1,2 @@
+export declare const CLI_VERSION = "0.13.4";
+//# sourceMappingURL=default.d.ts.map

package/dist/provisioning/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../provisioning/default.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,WAAW,CAAA"}

package/dist/provisioning/default.js

@@ -0,0 +1,2 @@
+// Code generated by dagger. DO NOT EDIT.
+export const CLI_VERSION = "0.13.4";

package/dist/provisioning/engineconn.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLClient } from "graphql-request";
+import { Writable } from "node:stream";
+export interface ConnectOpts {
+    Workdir?: string;
+    Project?: string;
+    LogOutput?: Writable;
+    Timeout?: number;
+}
+export interface ConnectParams {
+    port: number;
+    session_token: string;
+}
+export interface EngineConn {
+    /**
+     * Addr returns the connector address.
+     */
+    Addr: () => string;
+    /**
+     * Connect initializes a ready to use GraphQL Client that
+     * points to the engine.
+     */
+    Connect: (opts: ConnectOpts) => Promise<GraphQLClient>;
+    /**
+     * Close stops the current connection.
+     */
+    Close: () => Promise<void>;
+}
+//# sourceMappingURL=engineconn.d.ts.map

package/dist/provisioning/engineconn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineconn.d.ts","sourceRoot":"","sources":["../../provisioning/engineconn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,QAAQ,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,MAAM,CAAA;IAElB;;;OAGG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;IAEtD;;OAEG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B"}

package/dist/provisioning/engineconn.js

@@ -0,0 +1 @@
+export {};

package/dist/provisioning/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./default.js";
+export * from "./engineconn.js";
+export * from "./bin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/provisioning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../provisioning/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA"}

package/dist/provisioning/index.js

@@ -0,0 +1,3 @@
+export * from "./default.js";
+export * from "./engineconn.js";
+export * from "./bin.js";

package/dist/telemetry/attributes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=attributes.d.ts.map

package/dist/telemetry/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../telemetry/attributes.ts"],"names":[],"mappings":""}

package/dist/telemetry/attributes.js

@@ -0,0 +1 @@
+export {};

package/dist/telemetry/index.d.ts

@@ -0,0 +1,3 @@
+import { getTracer } from "./telemetry.js";
+export { getTracer };
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../telemetry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/telemetry/index.js

@@ -0,0 +1,2 @@
+import { getTracer } from "./telemetry.js";
+export { getTracer };

package/dist/telemetry/init.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A wrapper around the OpenTelemetry SDK to configure it for Dagger.
+ */
+export declare class DaggerOtelConfigurator {
+    private is_configured;
+    private sdk?;
+    /**
+     * Initialize the Open Telemetry SDK if enabled or not already configured.
+     */
+    initialize(): void;
+    configure(): void;
+    /**
+     * Shutdown the Open Telemetry SDK to flush traces and metrics and close the connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Setup environment for auto-configuring the SDK.
+     */
+    setupEnv(): void;
+}
+//# sourceMappingURL=init.d.ts.map

package/dist/telemetry/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../telemetry/init.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,aAAa,CAAQ;IAE7B,OAAO,CAAC,GAAG,CAAC,CAAS;IAErB;;OAEG;IACH,UAAU;IAQV,SAAS;IAoBT;;OAEG;IACG,KAAK;IAMX;;OAEG;IACH,QAAQ;CAeT"}

package/dist/telemetry/init.js

@@ -0,0 +1,66 @@
+import { getEnvWithoutDefaults } from "@opentelemetry/core";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+const SERVICE_NAME = "dagger-typescript-sdk";
+const env = getEnvWithoutDefaults();
+/*
+ * Look for variables prefixed with OTel to see if OpenTelemetry is configured.
+ */
+function otelConfigured() {
+    return Object.keys(process.env).some((key) => key.startsWith("OTEL_"));
+}
+/**
+ * A wrapper around the OpenTelemetry SDK to configure it for Dagger.
+ */
+export class DaggerOtelConfigurator {
+    is_configured = false;
+    sdk;
+    /**
+     * Initialize the Open Telemetry SDK if enabled or not already configured.
+     */
+    initialize() {
+        if (this.is_configured) {
+            return;
+        }
+        this.configure();
+        this.is_configured = true;
+    }
+    configure() {
+        if (!otelConfigured()) {
+            return;
+        }
+        if (env.OTEL_SDK_DISABLED) {
+            return;
+        }
+        this.setupEnv();
+        // Create the node SDK with the context manager, the resource and the exporter.
+        this.sdk = new NodeSDK({
+            serviceName: SERVICE_NAME,
+        });
+        // Register the SDK to the OpenTelemetry API
+        this.sdk.start();
+    }
+    /**
+     * Shutdown the Open Telemetry SDK to flush traces and metrics and close the connection.
+     */
+    async close() {
+        if (this.sdk) {
+            this.sdk.shutdown();
+        }
+    }
+    /**
+     * Setup environment for auto-configuring the SDK.
+     */
+    setupEnv() {
+        // TODO: The insecure flag should be set by the shim instead of the SDK.
+        Object.entries(process.env).forEach(([key, value]) => {
+            if (key.startsWith("OTEL_") &&
+                key.endsWith("_ENDPOINT") &&
+                value?.startsWith("http://")) {
+                const insecure = key.replace(/_ENDPOINT$/, "_INSECURE");
+                if (process.env[insecure] === undefined) {
+                    process.env[insecure] = "true";
+                }
+            }
+        });
+    }
+}

package/dist/telemetry/telemetry.d.ts

@@ -0,0 +1,16 @@
+import * as opentelemetry from "@opentelemetry/api";
+import { Tracer } from "./tracer.js";
+export declare function initialize(): void;
+export declare function close(): Promise<void>;
+/**
+ * Return a tracer to use with Dagger.
+ *
+ * The tracer is automatically initialized if not already done.
+ * As a conveniance function, you can use `withTracingSpan` that automatically close
+ * the span at the end of the function.
+ *
+ * You can add a custom name to the tracer based on your application.
+ */
+export declare function getTracer(name?: string): Tracer;
+export declare function getContext(): opentelemetry.Context;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../telemetry/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAMpC,wBAAgB,UAAU,SAEzB;AAED,wBAAsB,KAAK,kBAE1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,SAAqB,GAAG,MAAM,CAG3D;AAED,wBAAgB,UAAU,0BAgBzB"}

package/dist/telemetry/telemetry.js

@@ -0,0 +1,38 @@
+import * as opentelemetry from "@opentelemetry/api";
+import { DaggerOtelConfigurator } from "./init.js";
+import { Tracer } from "./tracer.js";
+const DAGGER_TRACER_NAME = "dagger.io/sdk.typescript";
+const configurator = new DaggerOtelConfigurator();
+export function initialize() {
+    configurator.initialize();
+}
+export async function close() {
+    await configurator.close();
+}
+/**
+ * Return a tracer to use with Dagger.
+ *
+ * The tracer is automatically initialized if not already done.
+ * As a conveniance function, you can use `withTracingSpan` that automatically close
+ * the span at the end of the function.
+ *
+ * You can add a custom name to the tracer based on your application.
+ */
+export function getTracer(name = DAGGER_TRACER_NAME) {
+    initialize();
+    return new Tracer(name);
+}
+export function getContext() {
+    const ctx = opentelemetry.context.active();
+    const spanCtx = opentelemetry.trace.getSpanContext(ctx);
+    if (spanCtx && opentelemetry.trace.isSpanContextValid(spanCtx)) {
+        return ctx;
+    }
+    const parentID = process.env.TRACEPARENT;
+    if (parentID) {
+        return opentelemetry.propagation.extract(ctx, {
+            traceparent: parentID,
+        });
+    }
+    return ctx;
+}

package/dist/telemetry/tracer.d.ts

@@ -0,0 +1,32 @@
+import * as opentelemetry from "@opentelemetry/api";
+/**
+ * Tracer encapsulates the OpenTelemetry Tracer.
+ */
+export declare class Tracer {
+    private tracer;
+    constructor(name: string);
+    startSpan(name: string, attributes?: opentelemetry.Attributes): opentelemetry.Span;
+    /**
+     * Execute the functions with a custom span with the given name using startActiveSpan.
+     * The function executed will use the parent context of the function (it can be another span
+     * or the main function).
+     *
+     * @param name The name of the span
+     * @param fn The functions to execute
+     *
+     * startActiveSpan returns the result of the executed functions.
+     *
+     * The span is automatically ended when the function is done.
+     * The span is automatically marked as an error if the function throws an error.
+     *
+     *
+     * @example
+     * ```
+     * return getTracer().startActiveSpan(name, async () => {
+     *   return this.containerEcho("test").stdout()
+     * })
+     * ```
+     */
+    startActiveSpan<T>(name: string, fn: (span: opentelemetry.Span) => Promise<T>, attributes?: opentelemetry.Attributes): Promise<T>;
+}
+//# sourceMappingURL=tracer.d.ts.map

package/dist/telemetry/tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../telemetry/tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAsB;gBAExB,IAAI,EAAE,MAAM;IAIjB,SAAS,CACd,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,aAAa,CAAC,UAAU,GACpC,aAAa,CAAC,IAAI;IAIrB;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,eAAe,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,UAAU,CAAC,EAAE,aAAa,CAAC,UAAU;CAoBxC"}