@acmekit/telemetry 2.13.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export function trackFeatureFlag(flag: any): void;
+export function trackInstallation(installation: any, type: any): void;
+export const flush: (() => Promise<void>) | undefined;
+export function track(event: any, data?: {}): void;
+export function setTelemetryEnabled(enabled?: boolean): void;
+export { default as Store } from "./store";
+export { default as Telemeter } from "./telemeter";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAmBA,kDAEC;AAED,sEASC;AA3BD,sDAA+D;AAMxD,mDAEN;AAEM,6DAEN"}

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Telemeter = exports.Store = exports.setTelemetryEnabled = exports.track = exports.flush = void 0;
+exports.trackFeatureFlag = trackFeatureFlag;
+exports.trackInstallation = trackInstallation;
+const telemeter_1 = __importDefault(require("./telemeter"));
+const create_flush_1 = __importDefault(require("./util/create-flush"));
+const telemeter = new telemeter_1.default();
+exports.flush = (0, create_flush_1.default)(telemeter.isTrackingEnabled());
+if (exports.flush) {
+    process.on(`exit`, exports.flush);
+}
+const track = (event, data = {}) => {
+    telemeter.track(event, data);
+};
+exports.track = track;
+const setTelemetryEnabled = (enabled = true) => {
+    telemeter.setTelemetryEnabled(enabled);
+};
+exports.setTelemetryEnabled = setTelemetryEnabled;
+function trackFeatureFlag(flag) {
+    telemeter.trackFeatureFlag(flag);
+}
+function trackInstallation(installation, type) {
+    switch (type) {
+        case `plugin`:
+            telemeter.trackPlugin(installation);
+            break;
+        case `module`:
+            telemeter.trackModule(installation);
+            break;
+    }
+}
+var store_1 = require("./store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return __importDefault(store_1).default; } });
+var telemeter_2 = require("./telemeter");
+Object.defineProperty(exports, "Telemeter", { enumerable: true, get: function () { return __importDefault(telemeter_2).default; } });

package/dist/postinstall.d.ts

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

package/dist/postinstall.d.ts.map

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

package/dist/postinstall.js

@@ -0,0 +1,15 @@
+"use strict";
+const { isCI } = require("./util/is-ci");
+try {
+    const showAnalyticsNotification = require(`./util/show-notification`);
+    const Store = require(`./store`);
+    const eventStorage = new Store();
+    const disabled = eventStorage.disabled_;
+    const enabledInConfig = eventStorage.getConfig(`telemetry.enabled`);
+    if (enabledInConfig === undefined && !disabled && !isCI()) {
+        showAnalyticsNotification();
+    }
+}
+catch (e) {
+    // ignore
+}

package/dist/store.d.ts

@@ -0,0 +1,16 @@
+export default Store;
+declare class Store {
+    config_: InMemoryConfigStore | Configstore;
+    outbox_: OutboxStore;
+    disabled_: boolean;
+    getQueueSize(): number;
+    getQueueCount(): number;
+    addEvent(event: any): void;
+    flushEvents(handler: any): Promise<boolean>;
+    getConfig(path: any): any;
+    setConfig(path: any, val: any): void;
+}
+import { InMemoryConfigStore } from "./util/in-memory-config";
+import Configstore from "configstore";
+import OutboxStore from "./util/outbox-store";
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.js"],"names":[],"mappings":";AAOA;IAGM,2CAAyE;IAM3E,qBAAuC;IAEvC,mBAA+D;IAGjE,uBAEC;IAED,wBAEC;IAED,2BAOC;IAED,4CASC;IAED,0BAEC;IAED,qCAEC;CACF;oCArDmC,yBAAyB;wBAHrC,aAAa;wBAKb,qBAAqB"}

package/dist/store.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const configstore_1 = __importDefault(require("configstore"));
+const path_1 = __importDefault(require("path"));
+const in_memory_config_1 = require("./util/in-memory-config");
+const is_truthy_1 = __importDefault(require("./util/is-truthy"));
+const outbox_store_1 = __importDefault(require("./util/outbox-store"));
+class Store {
+    constructor() {
+        try {
+            this.config_ = new configstore_1.default(`acmekit`, {}, { globalConfigPath: true });
+        }
+        catch (e) {
+            this.config_ = new in_memory_config_1.InMemoryConfigStore();
+        }
+        const baseDir = path_1.default.dirname(this.config_.path);
+        this.outbox_ = new outbox_store_1.default(baseDir);
+        this.disabled_ = (0, is_truthy_1.default)(process.env.MEDUSA_DISABLE_TELEMETRY);
+    }
+    getQueueSize() {
+        return this.outbox_.getSize();
+    }
+    getQueueCount() {
+        return this.outbox_.getCount();
+    }
+    addEvent(event) {
+        if (this.disabled_) {
+            return;
+        }
+        const eventString = JSON.stringify(event);
+        return this.outbox_.appendToBuffer(eventString + `\n`);
+    }
+    async flushEvents(handler) {
+        return await this.outbox_.startFlushEvents(async (eventData) => {
+            const events = eventData
+                .split(`\n`)
+                .filter((e) => e && e.length > 2)
+                .map((e) => JSON.parse(e));
+            return await handler(events);
+        });
+    }
+    getConfig(path) {
+        return this.config_.get(path);
+    }
+    setConfig(path, val) {
+        return this.config_.set(path, val);
+    }
+}
+exports.default = Store;

package/dist/telemeter.d.ts

@@ -0,0 +1,51 @@
+export default Telemeter;
+declare class Telemeter {
+    constructor(options?: {});
+    store_: Store;
+    flushAt: number;
+    maxQueueSize: any;
+    flushInterval: any;
+    flushed: boolean;
+    queueSize_: number;
+    queueCount_: number;
+    featureFlags_: Set<any>;
+    modules_: Set<any>;
+    plugins_: any[];
+    getMachineId(): any;
+    machineId: any;
+    isTrackingEnabled(): any;
+    trackingEnabled: any;
+    getOsInfo(): {
+        node_version: string;
+        platform: NodeJS.Platform;
+        release: string;
+        cpus: string | undefined;
+        is_ci: boolean;
+        ci_name: any;
+        arch: string;
+        docker: boolean;
+        term_program: string | undefined;
+    };
+    osInfo: {
+        node_version: string;
+        platform: NodeJS.Platform;
+        release: string;
+        cpus: string | undefined;
+        is_ci: boolean;
+        ci_name: any;
+        arch: string;
+        docker: boolean;
+        term_program: string | undefined;
+    } | undefined;
+    getAcmeKitVersion(): any;
+    getCliVersion(): any;
+    setTelemetryEnabled(enabled: any): void;
+    track(event: any, data: any): void;
+    enqueue_(type: any, data: any): void;
+    timer: NodeJS.Timeout | undefined;
+    trackFeatureFlag(flag: any): void;
+    trackModule(module: any): void;
+    trackPlugin(plugin: any): void;
+}
+import Store from "./store";
+//# sourceMappingURL=telemeter.d.ts.map

package/dist/telemeter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemeter.d.ts","sourceRoot":"","sources":["../src/telemeter.js"],"names":[],"mappings":";AAeA;IACE,0BAcC;IAbC,cAAyB;IAEzB,gBAAiD;IACjD,kBAAsD;IACtD,mBAAuD;IACvD,iBAAoB;IAEpB,mBAA4C;IAC5C,oBAA8C;IAE9C,wBAA8B;IAC9B,mBAAyB;IACzB,gBAAkB;IAGpB,oBAWC;IAFC,eAA0B;IAI5B,yBAeC;IAFC,qBAA8B;IAIhC;;;;;;;;;;MAkBC;IAFC;;;;;;;;;;kBAAoB;IAItB,yBAWC;IAED,qBAeC;IAED,wCAGC;IAED,mCAEC;IAED,qCAkCC;IAHK,kCAAkD;IAKxD,kCAIC;IAED,+BAIC;IAED,+BAIC;CACF;kBAxKiB,SAAS"}

package/dist/telemeter.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const is_docker_1 = __importDefault(require("is-docker"));
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const uuid_1 = require("uuid");
+const store_1 = __importDefault(require("./store"));
+const create_flush_1 = __importDefault(require("./util/create-flush"));
+const get_term_program_1 = __importDefault(require("./util/get-term-program"));
+const is_ci_1 = require("./util/is-ci");
+const is_truthy_1 = __importDefault(require("./util/is-truthy"));
+const show_notification_1 = __importDefault(require("./util/show-notification"));
+const MEDUSA_TELEMETRY_VERBOSE = process.env.MEDUSA_TELEMETRY_VERBOSE || false;
+class Telemeter {
+    constructor(options = {}) {
+        this.store_ = new store_1.default();
+        this.flushAt = Math.max(options.flushAt, 1) || 20;
+        this.maxQueueSize = options.maxQueueSize || 1024 * 500;
+        this.flushInterval = options.flushInterval || 10 * 1000;
+        this.flushed = false;
+        this.queueSize_ = this.store_.getQueueSize();
+        this.queueCount_ = this.store_.getQueueCount();
+        this.featureFlags_ = new Set();
+        this.modules_ = new Set();
+        this.plugins_ = [];
+    }
+    getMachineId() {
+        if (this.machineId) {
+            return this.machineId;
+        }
+        let machineId = this.store_.getConfig(`telemetry.machine_id`);
+        if (typeof machineId !== `string`) {
+            machineId = (0, uuid_1.v4)();
+            this.store_.setConfig(`telemetry.machine_id`, machineId);
+        }
+        this.machineId = machineId;
+        return machineId;
+    }
+    isTrackingEnabled() {
+        // Cache the result
+        if (this.trackingEnabled !== undefined) {
+            return this.trackingEnabled;
+        }
+        let enabled = this.store_.getConfig(`telemetry.enabled`);
+        if (enabled === undefined || enabled === null) {
+            if (!(0, is_ci_1.isCI)()) {
+                (0, show_notification_1.default)();
+            }
+            enabled = true;
+            this.store_.setConfig(`telemetry.enabled`, enabled);
+        }
+        this.trackingEnabled = enabled;
+        return enabled;
+    }
+    getOsInfo() {
+        if (this.osInfo) {
+            return this.osInfo;
+        }
+        const cpus = os_1.default.cpus();
+        const osInfo = {
+            node_version: process.version,
+            platform: os_1.default.platform(),
+            release: os_1.default.release(),
+            cpus: (cpus && cpus.length > 0 && cpus[0].model) || undefined,
+            is_ci: (0, is_ci_1.isCI)(),
+            ci_name: (0, is_ci_1.getCIName)(),
+            arch: os_1.default.arch(),
+            docker: (0, is_docker_1.default)(),
+            term_program: (0, get_term_program_1.default)(),
+        };
+        this.osInfo = osInfo;
+        return osInfo;
+    }
+    getAcmeKitVersion() {
+        try {
+            const packageJson = require.resolve(`@acmekit/acmekit/package.json`);
+            const { version } = JSON.parse(fs_1.default.readFileSync(packageJson, `utf-8`));
+            return version;
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("failed to get acmekit version", e);
+            }
+        }
+        return `-0.0.0`;
+    }
+    getCliVersion() {
+        try {
+            const jsonfile = (0, path_1.join)(require.resolve(`@acmekit/cli`).split(`${path_1.sep}dist`).shift(), "package.json");
+            const { version } = require(jsonfile);
+            return version;
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("failed to get acmekit version", e);
+            }
+        }
+        return `-0.0.0`;
+    }
+    setTelemetryEnabled(enabled) {
+        this.trackingEnabled = enabled;
+        this.store_.setConfig(`telemetry.enabled`, enabled);
+    }
+    track(event, data) {
+        return this.enqueue_(event, data);
+    }
+    enqueue_(type, data) {
+        const event = {
+            id: `te_${(0, uuid_1.v4)()}`,
+            type,
+            properties: data,
+            timestamp: new Date(),
+            machine_id: this.getMachineId(),
+            os_info: this.getOsInfo(),
+            acmekit_version: this.getAcmeKitVersion(),
+            cli_version: this.getCliVersion(),
+            feature_flags: Array.from(this.featureFlags_),
+            modules: Array.from(this.modules_),
+            plugins: this.plugins_,
+        };
+        this.store_.addEvent(event);
+        this.queueCount_ += 1;
+        this.queueSize_ += JSON.stringify(event).length;
+        const hasReachedFlushAt = this.queueCount_ >= this.flushAt;
+        const hasReachedQueueSize = this.queueSize_ >= this.maxQueueSize;
+        if (hasReachedQueueSize || hasReachedFlushAt) {
+            const flush = (0, create_flush_1.default)(this.isTrackingEnabled());
+            flush && flush();
+        }
+        if (this.flushInterval && !this.timer) {
+            const flush = (0, create_flush_1.default)(this.isTrackingEnabled());
+            if (flush) {
+                this.timer = setTimeout(flush, this.flushInterval);
+            }
+        }
+    }
+    trackFeatureFlag(flag) {
+        if (flag) {
+            this.featureFlags_.add(flag);
+        }
+    }
+    trackModule(module) {
+        if (module) {
+            this.modules_.add(module);
+        }
+    }
+    trackPlugin(plugin) {
+        if (plugin) {
+            this.plugins_.push(plugin);
+        }
+    }
+}
+exports.default = Telemeter;

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.js","../src/postinstall.js","../src/store.js","../src/telemeter.js","../src/util/create-flush.js","../src/util/get-term-program.js","../src/util/in-memory-config.js","../src/util/is-ci.js","../src/util/is-truthy.js","../src/util/outbox-store.js","../src/util/send.js","../src/util/show-notification.js","../src/util/telemetry-dispatcher.js"],"version":"5.9.3"}

package/dist/util/create-flush.d.ts

@@ -0,0 +1,3 @@
+export default createFlush;
+declare function createFlush(enabled: any): (() => Promise<void>) | undefined;
+//# sourceMappingURL=create-flush.d.ts.map

package/dist/util/create-flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-flush.d.ts","sourceRoot":"","sources":["../../src/util/create-flush.js"],"names":[],"mappings":";AAMA,8EAiBC"}

package/dist/util/create-flush.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const is_truthy_1 = __importDefault(require("./is-truthy"));
+const MEDUSA_TELEMETRY_VERBOSE = process.env.MEDUSA_TELEMETRY_VERBOSE || false;
+function createFlush(enabled) {
+    if (!enabled) {
+        return;
+    }
+    return async function flush() {
+        if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+            console.log("Flushing queue...");
+        }
+        const forked = (0, child_process_1.fork)((0, path_1.join)(__dirname, `send.js`), {
+            detached: true,
+            stdio: MEDUSA_TELEMETRY_VERBOSE ? `inherit` : `ignore`,
+            execArgv: [],
+        });
+        forked.unref();
+    };
+}
+exports.default = createFlush;

package/dist/util/get-term-program.d.ts

@@ -0,0 +1,3 @@
+export default getTermProgram;
+declare function getTermProgram(): string | undefined;
+//# sourceMappingURL=get-term-program.d.ts.map

package/dist/util/get-term-program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-term-program.d.ts","sourceRoot":"","sources":["../../src/util/get-term-program.js"],"names":[],"mappings":";AAAA,sDASC"}

package/dist/util/get-term-program.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getTermProgram() {
+    const { TERM_PROGRAM, WT_SESSION } = process.env;
+    if (TERM_PROGRAM) {
+        return TERM_PROGRAM;
+    }
+    else if (WT_SESSION) {
+        // https://github.com/microsoft/terminal/issues/1040
+        return `WindowsTerminal`;
+    }
+    return undefined;
+}
+exports.default = getTermProgram;

package/dist/util/in-memory-config.d.ts

@@ -0,0 +1,16 @@
+export class InMemoryConfigStore {
+    config: {};
+    path: string;
+    createBaseConfig(): {
+        "telemetry.enabled": boolean;
+        "telemetry.machine_id": string;
+    };
+    get(key: any): any;
+    set(key: any, value: any): void;
+    all(): {};
+    size(): number;
+    has(key: any): boolean;
+    del(key: any): void;
+    clear(): void;
+}
+//# sourceMappingURL=in-memory-config.d.ts.map

package/dist/util/in-memory-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-config.d.ts","sourceRoot":"","sources":["../../src/util/in-memory-config.js"],"names":[],"mappings":"AAIA;IACE,WAAW;IACX,aAAmC;IAMnC;;;MAKC;IAED,mBAEC;IAED,gCAEC;IAED,UAEC;IAED,eAEC;IAED,uBAEC;IAED,oBAEC;IAED,cAEC;CACF"}

package/dist/util/in-memory-config.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryConfigStore = void 0;
+const uuid_1 = require("uuid");
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+class InMemoryConfigStore {
+    constructor() {
+        this.config = {};
+        this.path = (0, path_1.join)(os_1.default.tmpdir(), `acmekit`);
+        this.config = this.createBaseConfig();
+    }
+    createBaseConfig() {
+        return {
+            "telemetry.enabled": true,
+            "telemetry.machine_id": `not-a-machine-id-${(0, uuid_1.v4)()}`,
+        };
+    }
+    get(key) {
+        return this.config[key];
+    }
+    set(key, value) {
+        this.config[key] = value;
+    }
+    all() {
+        return this.config;
+    }
+    size() {
+        return Object.keys(this.config).length;
+    }
+    has(key) {
+        return !!this.config[key];
+    }
+    del(key) {
+        delete this.config[key];
+    }
+    clear() {
+        this.config = this.createBaseConfig();
+    }
+}
+exports.InMemoryConfigStore = InMemoryConfigStore;

package/dist/util/is-ci.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Determines whether the environment where the code is running is in CI
+ * @return true if the environment is in CI, false otherwise
+ */
+export function isCI(): boolean;
+/**
+ * Gets the name of the CI environment (e.g. "Vercel", "Heroku", etc.)
+ * @return The name of the CI if available. Defaults to null if not in CI
+ */
+export function getCIName(): any;
+//# sourceMappingURL=is-ci.d.ts.map

package/dist/util/is-ci.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-ci.d.ts","sourceRoot":"","sources":["../../src/util/is-ci.js"],"names":[],"mappings":"AAiCA;;;GAGG;AAEH,gCAEC;AAED;;;GAGG;AAEH,iCAKC"}

package/dist/util/is-ci.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = isCI;
+exports.getCIName = getCIName;
+const ci_info_1 = __importDefault(require("ci-info"));
+const CI_DEFINITIONS = [
+    getEnvDetect({ key: `NOW_BUILDER_ANNOTATE`, name: `ZEIT Now` }),
+    getEnvDetect({ key: `NOW_REGION`, name: `ZEIT Now v1` }),
+    getEnvDetect({ key: `VERCEL_URL`, name: `Vercel Now` }),
+    getEnvDetect({ key: `NOW_BUILDER`, name: `Vercel Now` }),
+    getEnvDetect({ key: `VERCEL_BUILDER`, name: `Vercel Now` }),
+    getEnvDetect({ key: `CODESANDBOX_SSE`, name: `CodeSandbox` }),
+    getEnvDetect({ key: `GITHUB_ACTIONS`, name: `GitHub Actions` }),
+    getEnvDetect({ key: `CIRCLE_BRANCH`, name: `CircleCI` }),
+    getEnvDetect({ key: `CIRCLECI`, name: `CircleCI` }),
+    envFromCIAndCIName,
+    herokuDetect,
+    getEnvFromCIInfo,
+    envFromCIWithNoName,
+];
+function lookupCI() {
+    for (const fn of CI_DEFINITIONS) {
+        try {
+            const res = fn();
+            if (res) {
+                return res;
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    return null;
+}
+const CIName = lookupCI();
+/**
+ * Determines whether the environment where the code is running is in CI
+ * @return true if the environment is in CI, false otherwise
+ */
+function isCI() {
+    return !!CIName;
+}
+/**
+ * Gets the name of the CI environment (e.g. "Vercel", "Heroku", etc.)
+ * @return The name of the CI if available. Defaults to null if not in CI
+ */
+function getCIName() {
+    if (!isCI()) {
+        return null;
+    }
+    return CIName;
+}
+function getEnvFromCIInfo() {
+    if (ci_info_1.default.isCI)
+        return ci_info_1.default.name || `ci-info detected w/o name`;
+    return null;
+}
+function getEnvDetect({ key, name }) {
+    return function () {
+        if (process.env[key]) {
+            return name;
+        }
+        return null;
+    };
+}
+function herokuDetect() {
+    return (typeof process.env.NODE === `string` &&
+        /\.heroku\/node\/bin\/node/.test(process.env.NODE) &&
+        `Heroku`);
+}
+function envFromCIAndCIName() {
+    if (process.env.CI_NAME && process.env.CI) {
+        return process.env.CI_NAME;
+    }
+    return null;
+}
+function envFromCIWithNoName() {
+    if (process.env.CI) {
+        return `CI detected without name`;
+    }
+    return null;
+}

package/dist/util/is-truthy.d.ts

@@ -0,0 +1,3 @@
+export default isTruthy;
+declare function isTruthy(value: any): boolean;
+//# sourceMappingURL=is-truthy.d.ts.map

package/dist/util/is-truthy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.d.ts","sourceRoot":"","sources":["../../src/util/is-truthy.js"],"names":[],"mappings":";AAEA,+CAkBC"}

package/dist/util/is-truthy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Returns true for `true`, true, positive numbers
+// Returns false for `false`, false, 0, negative integers and anything else
+function isTruthy(value) {
+    // Return if Boolean
+    if (typeof value === `boolean`)
+        return value;
+    // Return false if null or undefined
+    if (value === undefined || value === null)
+        return false;
+    // If the String is true or false
+    if (value.toLowerCase() === `true`)
+        return true;
+    if (value.toLowerCase() === `false`)
+        return false;
+    // Now check if it's a number
+    const number = parseInt(value, 10);
+    if (isNaN(number))
+        return false;
+    if (number > 0)
+        return true;
+    // Default to false
+    return false;
+}
+exports.default = isTruthy;

package/dist/util/outbox-store.d.ts

@@ -0,0 +1,13 @@
+export default Outbox;
+declare class Outbox {
+    constructor(baseDir: any);
+    eventsJsonFileName: string;
+    bufferFilePath: string;
+    baseDir: any;
+    appendToBuffer(event: any): void;
+    getSize(): number;
+    getCount(): number;
+    flushFile(filePath: any, flushOperation: any): Promise<boolean>;
+    startFlushEvents(flushOperation: any): Promise<boolean>;
+}
+//# sourceMappingURL=outbox-store.d.ts.map

package/dist/util/outbox-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-store.d.ts","sourceRoot":"","sources":["../../src/util/outbox-store.js"],"names":[],"mappings":";AAeA;IACE,0BAIC;IAHC,2BAAuC;IACvC,uBAAiE;IACjE,aAAsB;IAGxB,iCAQC;IAED,kBAcC;IAED,mBAgBC;IAED,gEAkCC;IAED,wDAeC;CACF"}

package/dist/util/outbox-store.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const is_truthy_1 = __importDefault(require("./is-truthy"));
+const MEDUSA_TELEMETRY_VERBOSE = process.env.MEDUSA_TELEMETRY_VERBOSE || false;
+class Outbox {
+    constructor(baseDir) {
+        this.eventsJsonFileName = `events.json`;
+        this.bufferFilePath = path_1.default.join(baseDir, this.eventsJsonFileName);
+        this.baseDir = baseDir;
+    }
+    appendToBuffer(event) {
+        try {
+            (0, fs_1.appendFileSync)(this.bufferFilePath, event, `utf8`);
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("Failed to append to buffer", e);
+            }
+        }
+    }
+    getSize() {
+        if (!(0, fs_1.existsSync)(this.bufferFilePath)) {
+            return 0;
+        }
+        try {
+            const stats = (0, fs_1.statSync)(this.bufferFilePath);
+            return stats.size;
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("Failed to get outbox size", e);
+            }
+        }
+        return 0;
+    }
+    getCount() {
+        if (!(0, fs_1.existsSync)(this.bufferFilePath)) {
+            return 0;
+        }
+        try {
+            const fileBuffer = (0, fs_1.readFileSync)(this.bufferFilePath);
+            const str = fileBuffer.toString();
+            const lines = str.split("\n");
+            return lines.length - 1;
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("Failed to get outbox count", e);
+            }
+        }
+        return 0;
+    }
+    async flushFile(filePath, flushOperation) {
+        const now = `${Date.now()}-${process.pid}`;
+        let success = false;
+        let contents = ``;
+        try {
+            if (!(0, fs_1.existsSync)(filePath)) {
+                return true;
+            }
+            // Unique temporary file name across multiple concurrent AcmeKit instances
+            const newPath = `${this.bufferFilePath}-${now}`;
+            (0, fs_1.renameSync)(filePath, newPath);
+            contents = (0, fs_1.readFileSync)(newPath, `utf8`);
+            (0, fs_1.unlinkSync)(newPath);
+            // There is still a chance process dies while sending data and some events are lost
+            // This will be ok for now, however
+            success = await flushOperation(contents);
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("Failed to perform file flush", e);
+            }
+        }
+        finally {
+            // if sending fails, we write the data back to the log
+            if (!success) {
+                if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                    console.error("File flush did not succeed - writing back to file", success);
+                }
+                this.appendToBuffer(contents);
+            }
+        }
+        return true;
+    }
+    async startFlushEvents(flushOperation) {
+        try {
+            await this.flushFile(this.bufferFilePath, flushOperation);
+            const files = (0, fs_1.readdirSync)(this.baseDir);
+            const filtered = files.filter(p => p.startsWith(`events.json`));
+            for (const file of filtered) {
+                await this.flushFile(path_1.default.join(this.baseDir, file), flushOperation);
+            }
+            return true;
+        }
+        catch (e) {
+            if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                console.error("Failed to perform flush", e);
+            }
+        }
+        return false;
+    }
+}
+exports.default = Outbox;

package/dist/util/send.d.ts

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

package/dist/util/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/util/send.js"],"names":[],"mappings":""}

package/dist/util/send.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_dispatcher_1 = __importDefault(require("./telemetry-dispatcher"));
+const MEDUSA_TELEMETRY_HOST = process.env.MEDUSA_TELEMETRY_HOST || "";
+const MEDUSA_TELEMETRY_PATH = process.env.MEDUSA_TELEMETRY_PATH || "";
+const dispatcher = new telemetry_dispatcher_1.default({
+    host: MEDUSA_TELEMETRY_HOST,
+    path: MEDUSA_TELEMETRY_PATH,
+});
+dispatcher.dispatch();

package/dist/util/show-notification.d.ts

@@ -0,0 +1,10 @@
+export default showAnalyticsNotification;
+/**
+ * Analytics notice for the end-user
+ */
+declare function showAnalyticsNotification(config?: {
+    padding: number;
+    borderColor: string;
+    borderStyle: string;
+}, message?: string): void;
+//# sourceMappingURL=show-notification.d.ts.map

package/dist/util/show-notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-notification.d.ts","sourceRoot":"","sources":["../../src/util/show-notification.js"],"names":[],"mappings":";AAcA;;GAEG;AACH;;;;2BAKC"}

package/dist/util/show-notification.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const boxen_1 = __importDefault(require("boxen"));
+const defaultConfig = {
+    padding: 1,
+    borderColor: `blue`,
+    borderStyle: `double`,
+};
+const defaultMessage = `AcmeKit collects anonymous usage analytics\n` +
+    `to help improve AcmeKit for all users.\n` +
+    `\n` +
+    `If you'd like to opt-out, you can use \`acmekit telemetry --disable\`\n`;
+/**
+ * Analytics notice for the end-user
+ */
+function showAnalyticsNotification(config = defaultConfig, message = defaultMessage) {
+    console.log((0, boxen_1.default)(message, config));
+}
+exports.default = showAnalyticsNotification;

package/dist/util/telemetry-dispatcher.d.ts

@@ -0,0 +1,16 @@
+export default TelemetryDispatcher;
+declare class TelemetryDispatcher {
+    constructor(options: any);
+    store_: Store;
+    host: string;
+    path: string;
+    axiosInstance: any;
+    timeout: any;
+    flushed: boolean;
+    isTrackingEnabled(): any;
+    trackingEnabled: any;
+    dispatch(): Promise<void>;
+    isErrorRetryable_(error: any): boolean;
+}
+import Store from "../store";
+//# sourceMappingURL=telemetry-dispatcher.d.ts.map

package/dist/util/telemetry-dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry-dispatcher.d.ts","sourceRoot":"","sources":["../../src/util/telemetry-dispatcher.js"],"names":[],"mappings":";AAUA;IACE,0BAsBC;IArBC,cAAyB;IAEzB,aAEC;IACD,aAAiD;IAMjD,mBAAkC;IAElC,aAAuC;IACvC,iBAAoB;IAStB,yBAaC;IAFC,qBAA8B;IAIhC,0BAqCC;IAED,uCAsBC;CACF;kBA3GiB,UAAU"}

package/dist/util/telemetry-dispatcher.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const remove_trailing_slash_1 = __importDefault(require("remove-trailing-slash"));
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const show_notification_1 = __importDefault(require("./show-notification"));
+const store_1 = __importDefault(require("../store"));
+const is_truthy_1 = __importDefault(require("./is-truthy"));
+const MEDUSA_TELEMETRY_VERBOSE = process.env.MEDUSA_TELEMETRY_VERBOSE || false;
+class TelemetryDispatcher {
+    constructor(options) {
+        this.store_ = new store_1.default();
+        this.host = (0, remove_trailing_slash_1.default)(options.host || "https://telemetry.acmekit-commerce.com");
+        this.path = (0, remove_trailing_slash_1.default)(options.path || "/batch");
+        let axiosInstance = options.axiosInstance;
+        if (!axiosInstance) {
+            axiosInstance = axios_1.default.create();
+        }
+        this.axiosInstance = axiosInstance;
+        this.timeout = options.timeout || false;
+        this.flushed = false;
+        (0, axios_retry_1.default)(this.axiosInstance, {
+            retries: 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+            retryCondition: this.isErrorRetryable_,
+        });
+    }
+    isTrackingEnabled() {
+        // Cache the result
+        if (this.trackingEnabled !== undefined) {
+            return this.trackingEnabled;
+        }
+        let enabled = this.store_.getConfig(`telemetry.enabled`);
+        if (enabled === undefined || enabled === null) {
+            (0, show_notification_1.default)();
+            enabled = true;
+            this.store_.setConfig(`telemetry.enabled`, enabled);
+        }
+        this.trackingEnabled = enabled;
+        return enabled;
+    }
+    async dispatch() {
+        if (!this.isTrackingEnabled()) {
+            return;
+        }
+        await this.store_.flushEvents(async (events) => {
+            if (!events.length) {
+                if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                    console.log("No events to POST - skipping");
+                }
+                return true;
+            }
+            const data = {
+                batch: events,
+                timestamp: new Date(),
+            };
+            const req = {
+                headers: {},
+            };
+            return await this.axiosInstance
+                .post(`${this.host}${this.path}`, data, req)
+                .then(() => {
+                if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                    console.log("POSTing batch succeeded");
+                }
+                return true;
+            })
+                .catch(e => {
+                if ((0, is_truthy_1.default)(MEDUSA_TELEMETRY_VERBOSE)) {
+                    console.error("Failed to POST event batch", e);
+                }
+                return false;
+            });
+        });
+    }
+    isErrorRetryable_(error) {
+        // Retry Network Errors.
+        if (axios_retry_1.default.isNetworkError(error)) {
+            return true;
+        }
+        if (!error.response) {
+            // Cannot determine if the request can be retried
+            return false;
+        }
+        // Retry Server Errors (5xx).
+        if (error.response.status >= 500 && error.response.status <= 599) {
+            return true;
+        }
+        // Retry if rate limited.
+        if (error.response.status === 429) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.default = TelemetryDispatcher;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@acmekit/telemetry",
+  "version": "2.13.1",
+  "description": "Telemetry for AcmeKit",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/acmekit/acmekit",
+    "directory": "packages/acmekit-telemetry"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Sebastian Rindom",
+  "license": "MIT",
+  "scripts": {
+    "start": "nodemon --watch plugins/ --watch src/ --exec node src/index.js",
+    "prepare": "cross-env NODE_ENV=production yarn run build",
+    "watch": "yarn run -T tsc --build --watch",
+    "build": "yarn run -T rimraf dist && yarn run -T tsc --build",
+    "serve": "node dist/index.js",
+    "postinstall": "node dist/postinstall.js || true",
+    "test": "../../node_modules/.bin/jest --passWithNoTests src"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.26.10",
+    "axios": "^1.13.1",
+    "axios-retry": "^3.1.9",
+    "boxen": "^5.0.1",
+    "ci-info": "^3.2.0",
+    "configstore": "^5.0.1",
+    "is-docker": "^2.2.1",
+    "remove-trailing-slash": "^0.1.1",
+    "uuid": "^9.0.0"
+  },
+  "gitHead": "41a5425405aea5045a26def95c0dc00cf4a5a44d"
+}