@shuvi/reporters 1.0.30

package/lib/helper/anonymous-meta.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+declare type PackageManager = {
+    packageManager: 'npm' | 'pnpm' | 'yarn';
+    packageManagerVersion: string | undefined;
+};
+declare type AnonymousMeta = {
+    systemPlatform: NodeJS.Platform;
+    systemRelease: string;
+    systemArchitecture: string;
+    cpuCount: number;
+    cpuModel: string | null;
+    cpuSpeed: number | null;
+    memoryInMb: number;
+    isDocker: boolean;
+    isWsl: boolean;
+    isCI: boolean;
+    ciName: string | null;
+    packageManager: string;
+    packageManagerVersion: string | undefined;
+    nodeVersion: string;
+    shuviVersion?: string;
+};
+export declare function getAnonymousMeta(): AnonymousMeta;
+export declare function getPkgManager(): PackageManager;
+export {};

package/lib/helper/anonymous-meta.js

@@ -0,0 +1,99 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPkgManager = exports.getAnonymousMeta = void 0;
+const is_docker_1 = __importDefault(require("is-docker"));
+const is_wsl_1 = __importDefault(require("is-wsl"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const ciEnvironment = __importStar(require("ci-info"));
+let traits;
+function getAnonymousMeta() {
+    if (traits) {
+        return traits;
+    }
+    const cpus = os_1.default.cpus() || [];
+    const { packageManager, packageManagerVersion } = getPkgManager();
+    traits = {
+        // Software information
+        systemPlatform: os_1.default.platform(),
+        systemRelease: os_1.default.release(),
+        systemArchitecture: os_1.default.arch(),
+        // Machine information
+        cpuCount: cpus.length,
+        cpuModel: cpus.length ? cpus[0].model : null,
+        cpuSpeed: cpus.length ? cpus[0].speed : null,
+        memoryInMb: Math.trunc(os_1.default.totalmem() / Math.pow(1024, 2)),
+        // Environment information
+        isDocker: (0, is_docker_1.default)(),
+        isWsl: is_wsl_1.default,
+        isCI: ciEnvironment.isCI,
+        ciName: (ciEnvironment.isCI && ciEnvironment.name) || null,
+        packageManager,
+        packageManagerVersion,
+        nodeVersion: process.version
+    };
+    return traits;
+}
+exports.getAnonymousMeta = getAnonymousMeta;
+function getPkgManager() {
+    try {
+        const userAgent = process.env.npm_config_user_agent;
+        if (userAgent) {
+            const packageManagerVersion = userAgent.split(' ')[0].split('/')[1];
+            if (userAgent.startsWith('yarn')) {
+                return { packageManager: 'yarn', packageManagerVersion };
+            }
+            else if (userAgent.startsWith('pnpm')) {
+                return { packageManager: 'pnpm', packageManagerVersion };
+            }
+        }
+        try {
+            const packageManagerVersion = (0, child_process_1.execSync)(`yarn --version`)
+                .toString()
+                .trim();
+            return { packageManager: 'yarn', packageManagerVersion };
+        }
+        catch (_a) {
+            const packageManagerVersion = (0, child_process_1.execSync)(`pnpm --version`)
+                .toString()
+                .trim();
+            return { packageManager: 'pnpm', packageManagerVersion };
+        }
+    }
+    catch (_b) {
+        try {
+            const packageManagerVersion = (0, child_process_1.execSync)(`npm --version`).toString().trim();
+            return { packageManager: 'npm', packageManagerVersion };
+        }
+        catch (_c) {
+            return { packageManager: 'npm', packageManagerVersion: undefined };
+        }
+    }
+}
+exports.getPkgManager = getPkgManager;

package/lib/helper/post-payload.d.ts

@@ -0,0 +1 @@
+export declare function _postPayload(endpoint: string, body: object): Promise<void>;

package/lib/helper/post-payload.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._postPayload = void 0;
+const async_retry_1 = __importDefault(require("async-retry"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+function _postPayload(endpoint, body) {
+    return ((0, async_retry_1.default)(() => (0, node_fetch_1.default)(endpoint, {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers: { 'content-type': 'application/json' },
+        timeout: 5000
+    }).then(res => {
+        if (!res.ok) {
+            const err = new Error(res.statusText);
+            err.response = res;
+            throw err;
+        }
+    }), { minTimeout: 500, retries: 1, factor: 1 })
+        .catch(() => {
+        // We swallow errors when telemetry cannot be sent
+    })
+        // Ensure promise is voided
+        .then(() => { }, () => { }));
+}
+exports._postPayload = _postPayload;

package/lib/helper/project-id.d.ts

@@ -0,0 +1 @@
+export declare function getRawProjectId(): string;

package/lib/helper/project-id.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRawProjectId = void 0;
+const child_process_1 = require("child_process");
+function _getProjectIdByGit() {
+    try {
+        const originBuffer = (0, child_process_1.execSync)(`git config --local --get remote.origin.url`, {
+            timeout: 1000,
+            stdio: `pipe`
+        });
+        return String(originBuffer).trim();
+    }
+    catch (_) {
+        return null;
+    }
+}
+function getRawProjectId() {
+    return _getProjectIdByGit() || process.env.REPOSITORY_URL || process.cwd();
+}
+exports.getRawProjectId = getRawProjectId;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './telemetry';
+export * from './to-json';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// This package 'telemetry' is a modified version of the Next.js that can be found here:
+// https://github.com/vercel/next.js/tree/canary/packages/next/telemetry
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./telemetry"), exports);
+__exportStar(require("./to-json"), exports);

package/lib/telemetry.d.ts

@@ -0,0 +1,49 @@
+import type { Reporter } from '@shuvi/shared/reporter';
+export declare type TelemetryEvent = {
+    eventName: string;
+    payload: object;
+};
+export declare type EventContext = {
+    anonymousId?: string;
+    projectId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+};
+export declare type EventMeta = {
+    [key: string]: unknown;
+};
+export declare type EventBatchShape = {
+    eventName: string;
+    fields: object;
+};
+export declare type RecordObject = {
+    isFulfilled: boolean;
+    isRejected: boolean;
+    value?: any;
+    reason?: any;
+};
+export declare class Telemetry {
+    private name;
+    private conf;
+    private sessionId;
+    private rawProjectId;
+    private projectId;
+    private meta;
+    private context;
+    private postEndpoint;
+    private queue;
+    constructor({ name, meta, context, postEndpoint }: {
+        name: string;
+        meta?: EventMeta;
+        context?: EventContext;
+        postEndpoint?: string;
+    });
+    get anonymousId(): string;
+    get salt(): string;
+    report: Reporter;
+    record(_events: TelemetryEvent | TelemetryEvent[]): Promise<RecordObject>;
+    flush(): Promise<void>;
+    private _notify;
+    private _oneWayHash;
+    private _submitRecord;
+}

package/lib/telemetry.js

@@ -0,0 +1,171 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Telemetry = void 0;
+const chalk_1 = __importDefault(require("@shuvi/utils/chalk"));
+const conf_1 = __importDefault(require("conf"));
+const crypto_1 = require("crypto");
+const anonymous_meta_1 = require("./helper/anonymous-meta");
+const post_payload_1 = require("./helper/post-payload");
+const project_id_1 = require("./helper/project-id");
+// This is the key that specifies when the user was informed about anonymous
+// telemetry collection.
+const TELEMETRY_KEY_NOTIFY_DATE = 'telemetry.notifiedAt';
+// This is a quasi-persistent identifier used to dedupe recurring events. It's
+// generated from random data and completely anonymous.
+const TELEMETRY_KEY_ID = `telemetry.anonymousId`;
+// This is the cryptographic salt that is included within every hashed value.
+// This salt value is never sent to us, ensuring privacy and the one-way nature
+// of the hash (prevents dictionary lookups of pre-computed hashes).
+// See the `oneWayHash` function.
+const TELEMETRY_KEY_SALT = `telemetry.salt`;
+class Telemetry {
+    constructor({ name, meta, context, postEndpoint }) {
+        this.report = ({ timestamp, name, duration, startTime, id, parentId, attrs }) => {
+            this.record({
+                eventName: name,
+                payload: {
+                    parentId,
+                    name,
+                    id,
+                    startTime,
+                    duration,
+                    timestamp,
+                    tags: attrs
+                }
+            });
+        };
+        try {
+            // `conf` incorrectly throws a permission error during initialization
+            // instead of waiting for first use. We need to handle it, otherwise the
+            // process may crash.
+            this.conf = new conf_1.default({ projectName: 'shuvijs' });
+        }
+        catch (_) {
+            this.conf = null;
+        }
+        this.name = name;
+        this.sessionId = (0, crypto_1.randomBytes)(32).toString('hex');
+        this.rawProjectId = (0, project_id_1.getRawProjectId)();
+        this.projectId = this._oneWayHash(this.rawProjectId);
+        this.postEndpoint = postEndpoint;
+        this.queue = new Set();
+        this._notify();
+        this.meta = Object.assign(Object.assign({}, (0, anonymous_meta_1.getAnonymousMeta)()), meta);
+        this.context = Object.assign({ anonymousId: this.anonymousId, projectId: this.projectId, sessionId: this.sessionId }, context);
+        Object.freeze(this.meta);
+        Object.freeze(this.context);
+    }
+    get anonymousId() {
+        const val = this.conf && this.conf.get(TELEMETRY_KEY_ID);
+        if (val) {
+            return val;
+        }
+        const generated = (0, crypto_1.randomBytes)(32).toString('hex');
+        this.conf && this.conf.set(TELEMETRY_KEY_ID, generated);
+        return generated;
+    }
+    get salt() {
+        const val = this.conf && this.conf.get(TELEMETRY_KEY_SALT);
+        if (val) {
+            return val;
+        }
+        const generated = (0, crypto_1.randomBytes)(16).toString('hex');
+        this.conf && this.conf.set(TELEMETRY_KEY_SALT, generated);
+        return generated;
+    }
+    record(_events) {
+        const _this = this;
+        // pseudo try-catch
+        function wrapper() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield _this._submitRecord(_events);
+            });
+        }
+        const prom = wrapper()
+            .then(value => ({
+            isFulfilled: true,
+            isRejected: false,
+            value
+        }))
+            .catch(reason => ({
+            isFulfilled: false,
+            isRejected: true,
+            reason
+        }))
+            // Acts as `Promise#finally` because `catch` transforms the error
+            .then(res => {
+            // Clean up the event to prevent unbounded `Set` growth
+            this.queue.delete(prom);
+            return res;
+        });
+        // Track this `Promise` so we can flush pending events
+        this.queue.add(prom);
+        return prom;
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.queue).catch(() => null);
+        });
+    }
+    _notify() {
+        if (!this.conf) {
+            return;
+        }
+        // The end-user has already been notified about our telemetry integration. We
+        // don't need to constantly annoy them about it.
+        // We will re-inform users about the telemetry if significant changes are
+        // ever made.
+        if (this.conf.get(TELEMETRY_KEY_NOTIFY_DATE, '')) {
+            return;
+        }
+        this.conf.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now().toString());
+        console.log(`${chalk_1.default.magenta.bold('Attention')}: ${this.name} now collects completely anonymous telemetry regarding usage.`);
+        console.log();
+    }
+    _oneWayHash(payload) {
+        const hash = (0, crypto_1.createHash)('sha256');
+        // Always prepend the payload value with salt. This ensures the hash is truly
+        // one-way.
+        hash.update(this.salt);
+        // Update is an append operation, not a replacement. The salt from the prior
+        // update is still present!
+        hash.update(payload);
+        return hash.digest('hex');
+    }
+    _submitRecord(_events) {
+        let events;
+        if (Array.isArray(_events)) {
+            events = _events;
+        }
+        else {
+            events = [_events];
+        }
+        if (events.length < 1) {
+            return Promise.resolve();
+        }
+        if (!this.postEndpoint) {
+            return Promise.resolve();
+        }
+        return (0, post_payload_1._postPayload)(this.postEndpoint, {
+            context: this.context,
+            meta: this.meta,
+            events: events.map(({ eventName, payload }) => ({
+                eventName,
+                fields: payload
+            }))
+        });
+    }
+}
+exports.Telemetry = Telemetry;

package/lib/to-json.d.ts

@@ -0,0 +1,11 @@
+import type { Reporter } from '@shuvi/shared/reporter';
+export declare class ToJson {
+    private phase;
+    private buildDir;
+    private traceId;
+    private writeStream;
+    private batch;
+    constructor(phase: string, buildDir: string, traceId: string);
+    flushAll: () => void;
+    report: Reporter;
+}

package/lib/to-json.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToJson = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Batch events as zipkin allows for multiple events to be sent in one go
+function batcher(reportEvents) {
+    const events = [];
+    // Promise queue to ensure events are always sent on flushAll
+    const queue = new Set();
+    return {
+        flushAll: () => __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(queue);
+            if (events.length > 0) {
+                yield reportEvents(events);
+                events.length = 0;
+            }
+        }),
+        report: (event) => {
+            events.push(event);
+            if (events.length > 100) {
+                const evts = events.slice();
+                events.length = 0;
+                const report = reportEvents(evts);
+                queue.add(report);
+                report.then(() => queue.delete(report));
+            }
+        }
+    };
+}
+const writeStreamOptions = {
+    flags: 'a',
+    encoding: 'utf8'
+};
+class RotatingWriteStream {
+    constructor(file, sizeLimit) {
+        this.file = file;
+        this.size = 0;
+        this.sizeLimit = sizeLimit;
+        this.createWriteStream();
+    }
+    createWriteStream() {
+        this.writeStream = fs_1.default.createWriteStream(this.file, writeStreamOptions);
+    }
+    // Recreate the file
+    rotate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.end();
+            try {
+                fs_1.default.unlinkSync(this.file);
+            }
+            catch (err) {
+                // It's fine if the file does not exist yet
+                if (err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+            this.size = 0;
+            this.createWriteStream();
+            this.rotatePromise = undefined;
+        });
+    }
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.rotatePromise)
+                yield this.rotatePromise;
+            this.size += data.length;
+            if (this.size > this.sizeLimit) {
+                yield (this.rotatePromise = this.rotate());
+            }
+            if (!this.writeStream.write(data, 'utf8')) {
+                if (this.drainPromise === undefined) {
+                    this.drainPromise = new Promise((resolve, _reject) => {
+                        this.writeStream.once('drain', () => {
+                            this.drainPromise = undefined;
+                            resolve();
+                        });
+                    });
+                }
+                yield this.drainPromise;
+            }
+        });
+    }
+    end() {
+        return new Promise(resolve => {
+            this.writeStream.end(resolve);
+        });
+    }
+}
+class ToJson {
+    constructor(phase, buildDir, traceId) {
+        this.flushAll = () => {
+            this.batch.flushAll().then(() => {
+                var _a;
+                // Only end writeStream when manually flushing in production
+                if (this.phase !== 'PHASE_DEVELOPMENT_SERVER') {
+                    (_a = this.writeStream) === null || _a === void 0 ? void 0 : _a.end();
+                }
+            });
+        };
+        this.report = ({ timestamp, name, duration, startTime, id, parentId, attrs }) => {
+            if (!this.buildDir || !this.phase) {
+                return;
+            }
+            this.batch.report({
+                traceId: this.traceId,
+                parentId,
+                name,
+                id,
+                startTime,
+                duration,
+                timestamp,
+                tags: attrs
+            });
+        };
+        this.phase = phase;
+        this.buildDir = buildDir;
+        this.traceId = traceId || (0, crypto_1.randomBytes)(8).toString('hex');
+        this.batch = batcher((events) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.writeStream) {
+                yield fs_1.default.promises.mkdir(this.buildDir, { recursive: true });
+                const file = path_1.default.join(this.buildDir, 'trace');
+                this.writeStream = new RotatingWriteStream(file, 
+                // Development is limited to 50MB, production is unlimited
+                this.phase === 'PHASE_DEVELOPMENT_SERVER' ? 52428800 : Infinity);
+            }
+            const eventsJson = JSON.stringify(events);
+            try {
+                yield this.writeStream.write(eventsJson + '\n');
+            }
+            catch (err) {
+                console.log(err);
+            }
+        }));
+    }
+}
+exports.ToJson = ToJson;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@shuvi/reporters",
+  "version": "1.0.30",
+  "author": "liximomo",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "dev": "tsc -p tsconfig.build.json -m commonjs -w",
+    "prebuild": "rimraf lib",
+    "build": "tsc -p tsconfig.build.json -m commonjs"
+  },
+  "dependencies": {
+    "@shuvi/shared": "1.0.30",
+    "@shuvi/utils": "1.0.30",
+    "conf": "5.0.0",
+    "is-docker": "2.0.0",
+    "is-wsl": "2.2.0",
+    "ci-info": "3.6.2",
+    "async-retry": "1.3.3",
+    "node-fetch": "2.6.7"
+  },
+  "devDependencies": {
+    "@types/async-retry": "1.3.0",
+    "@types/node-fetch": "2.6.1"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  }
+}