[telemetry] Rewrite Telemetry module to be more universal

README.md

@@ -16,16 +16,15 @@ A set of plugins to interact with Datadog directly from your builds.
 
 <!-- #toc -->
 -   [Bundler Plugins](#bundler-plugins)
-    -   [ESBuild](#esbuild)
-    -   [Rollup](#rollup)
-    -   [Vite](#vite)
-    -   [Webpack](#webpack)
+    -   [ESBuild](#-esbuild)
+    -   [Rollup](#-rollup)
+    -   [Vite](#-vite)
+    -   [Webpack](#-webpack)
 -   [Features](#features)
-    -   [RUM](#rum)
-    -   [Telemetry](#telemetry)
+    -   [RUM](#rum----)
+    -   [Telemetry](#telemetry--)
 -   [Configuration](#configuration)
     -   [`auth.apiKey`](#authapikey)
-    -   [`auth.endPoint`](#authendpoint)
     -   [`logLevel`](#loglevel)
 -   [Contributing](#contributing)
 -   [License](#license)
@@ -223,6 +222,7 @@ datadogWebpackPlugin({
 datadogWebpackPlugin({
     telemetry?: {
         disabled?: boolean,
+        endPoint?: string,
         output?: boolean
             | string
             | {
@@ -251,7 +251,6 @@ datadogWebpackPlugin({
 {
     auth?: {
         apiKey?: string;
-        endPoint?: string;
     };
     logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'none';
     rum?: {
@@ -267,6 +266,7 @@ datadogWebpackPlugin({
     };
     telemetry?: {
         disabled?: boolean;
+        endPoint?: string;
         output?: boolean
             | string
             | {
@@ -292,12 +292,6 @@ datadogWebpackPlugin({
 
 In order to interact with Datadog, you have to use [your own API Key](https://app.datadoghq.com/organization-settings/api-keys).
 
-### `auth.endPoint`
-
-> default: `"app.datadoghq.com"`
-
-To which endpoint will the metrics be sent.
-
 ### `logLevel`
 
 > default: `'warn'`

package.json

@@ -9,7 +9,8 @@
     "repository": "git://github.com/DataDog/build-plugins.git",
     "workspaces": [
         "packages/*",
-        "packages/plugins/*"
+        "packages/plugins/*",
+        "packages/tests/src/fixtures/project"
     ],
     "volta": {
         "node": "18.19.0",

packages/core/src/plugins/build-report/esbuild.ts

@@ -0,0 +1,279 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import path from 'path';
+import type { UnpluginOptions } from 'unplugin';
+
+import type { Logger } from '../../log';
+import type { Entry, GlobalContext, Input, Output } from '../../types';
+
+import { cleanName, getType } from './helpers';
+
+// Re-index metafile data for easier access.
+const reIndexMeta = <T>(obj: Record<string, T>, cwd: string) =>
+    Object.fromEntries(
+        Object.entries(obj).map(([key, value]) => {
+            const newKey = path.join(cwd, key);
+            return [newKey, value];
+        }),
+    );
+
+export const getEsbuildPlugin = (
+    context: GlobalContext,
+    log: Logger,
+): UnpluginOptions['esbuild'] => {
+    return {
+        setup(build) {
+            const cwd = context.cwd;
+
+            // Store entry names based on the configuration.
+            const entrypoints = build.initialOptions.entryPoints;
+            const entryNames = new Map();
+            if (Array.isArray(entrypoints)) {
+                // We don't have an indexed object as entry, so we can't get an entry name from it.
+                for (const entry of entrypoints) {
+                    const fullPath = entry && typeof entry === 'object' ? entry.in : entry;
+                    const realEntry = cleanName(context, fullPath);
+                    entryNames.set(realEntry, realEntry);
+                }
+            } else if (entrypoints) {
+                const entryList = entrypoints ? Object.entries(entrypoints) : [];
+                for (const [entryName, entryPath] of entryList) {
+                    entryNames.set(cleanName(context, entryPath), entryName);
+                }
+            }
+
+            build.onEnd((result) => {
+                context.build.errors = result.errors.map((err) => err.text);
+                context.build.warnings = result.warnings.map((err) => err.text);
+
+                const warn = (warning: string) => {
+                    context.build.warnings.push(warning);
+                    log(warning, 'warn');
+                };
+
+                if (!result.metafile) {
+                    warn('Missing metafile from build result.');
+                    return;
+                }
+
+                const inputs: Input[] = [];
+                const outputs: Output[] = [];
+                const tempEntryFiles: Entry[] = [];
+                const tempSourcemaps: Output[] = [];
+                const entries: Entry[] = [];
+
+                const reportInputsIndexed: Record<string, Input> = {};
+                const reportOutputsIndexed: Record<string, Output> = {};
+
+                const metaInputsIndexed = reIndexMeta(result.metafile.inputs, cwd);
+                const metaOutputsIndexed = reIndexMeta(result.metafile.outputs, cwd);
+
+                // Loop through inputs.
+                for (const [filename, input] of Object.entries(result.metafile.inputs)) {
+                    const filepath = path.join(cwd, filename);
+                    const file: Input = {
+                        name: cleanName(context, filename),
+                        filepath,
+                        dependents: [],
+                        dependencies: [],
+                        size: input.bytes,
+                        type: getType(filename),
+                    };
+                    reportInputsIndexed[filepath] = file;
+                    inputs.push(file);
+                }
+
+                // Loop through outputs.
+                for (const [filename, output] of Object.entries(result.metafile.outputs)) {
+                    const fullPath = path.join(cwd, filename);
+                    const cleanedName = cleanName(context, fullPath);
+                    // Get inputs of this output.
+                    const inputFiles: Input[] = [];
+                    for (const inputName of Object.keys(output.inputs)) {
+                        const inputFound = reportInputsIndexed[path.join(cwd, inputName)];
+                        if (!inputFound) {
+                            warn(`Input ${inputName} not found for output ${cleanedName}`);
+                            continue;
+                        }
+
+                        inputFiles.push(inputFound);
+                    }
+
+                    // When splitting, esbuild creates an empty entryPoint wrapper for the chunk.
+                    // It has no inputs, but still relates to its entryPoint.
+                    if (output.entryPoint && !inputFiles.length) {
+                        const inputFound = reportInputsIndexed[path.join(cwd, output.entryPoint!)];
+                        if (!inputFound) {
+                            warn(`Input ${output.entryPoint} not found for output ${cleanedName}`);
+                            continue;
+                        }
+                        inputFiles.push(inputFound);
+                    }
+
+                    const file: Output = {
+                        name: cleanedName,
+                        filepath: fullPath,
+                        inputs: inputFiles,
+                        size: output.bytes,
+                        type: getType(fullPath),
+                    };
+
+                    reportOutputsIndexed[fullPath] = file;
+
+                    // Store sourcemaps for later filling.
+                    if (file.type === 'map') {
+                        tempSourcemaps.push(file);
+                    }
+
+                    outputs.push(file);
+
+                    if (!output.entryPoint) {
+                        continue;
+                    }
+
+                    const inputFile = reportInputsIndexed[path.join(cwd, output.entryPoint!)];
+
+                    if (inputFile) {
+                        // In the case of "splitting: true", all the files are considered entries to esbuild.
+                        // Not to us.
+                        // Verify we have listed it as an entry earlier.
+                        if (!entryNames.get(inputFile.name)) {
+                            continue;
+                        }
+
+                        const entry = {
+                            ...file,
+                            name: entryNames.get(inputFile.name) || inputFile.name,
+                            outputs: [file],
+                            size: file.size,
+                        };
+
+                        tempEntryFiles.push(entry);
+                    }
+                }
+
+                // Loop through sourcemaps.
+                for (const sourcemap of tempSourcemaps) {
+                    const outputFilepath = sourcemap.filepath.replace(/\.map$/, '');
+                    const foundOutput = reportOutputsIndexed[outputFilepath];
+
+                    if (!foundOutput) {
+                        warn(`Could not find output for sourcemap ${sourcemap.name}`);
+                        continue;
+                    }
+
+                    sourcemap.inputs.push(foundOutput);
+                }
+
+                // Build our references for the entries.
+                const references = {
+                    inputs: {
+                        report: reportInputsIndexed,
+                        meta: metaInputsIndexed,
+                    },
+                    outputs: {
+                        report: reportOutputsIndexed,
+                        meta: metaOutputsIndexed,
+                    },
+                };
+
+                // Go through all imports.
+                const getAllImports = <T extends Input | Output>(
+                    filePath: string,
+                    ref: typeof references.inputs | typeof references.outputs,
+                    allImports: Record<string, T> = {},
+                ): Record<string, T> => {
+                    const file = ref.report[filePath];
+                    if (!file) {
+                        warn(`Could not find report's ${filePath}`);
+                        return allImports;
+                    }
+
+                    // Check if we already have processed it.
+                    if (allImports[filePath]) {
+                        return allImports;
+                    }
+
+                    allImports[file.filepath] = file as T;
+
+                    const metaFile = ref.meta[filePath];
+                    if (!metaFile) {
+                        warn(`Could not find metafile's ${filePath}`);
+                        return allImports;
+                    }
+
+                    // If there are no imports, we can return what we have.
+                    if (!metaFile.imports || !metaFile.imports.length) {
+                        return allImports;
+                    }
+
+                    for (const imported of metaFile.imports) {
+                        const importPath = path.join(cwd, imported.path);
+                        // Look for the other inputs.
+                        getAllImports<T>(importPath, ref, allImports);
+                    }
+
+                    return allImports;
+                };
+
+                // Loop through entries.
+                for (const entryFile of tempEntryFiles) {
+                    const entryInputs: Record<string, Input> = {};
+                    const entryOutputs: Record<string, Output> = {};
+
+                    // Do inputs for this entry.
+                    for (const input of entryFile.inputs) {
+                        getAllImports<Input>(input.filepath, references.inputs, entryInputs);
+                    }
+
+                    // Do outputs for this entry.
+                    for (const outputFile of entryFile.outputs) {
+                        getAllImports<Output>(
+                            outputFile.filepath,
+                            references.outputs,
+                            entryOutputs,
+                        );
+                    }
+
+                    entryFile.inputs = Object.values(entryInputs);
+                    entryFile.outputs = Object.values(entryOutputs);
+                    entryFile.size = entryFile.outputs.reduce(
+                        (acc, output) => acc + output.size,
+                        0,
+                    );
+
+                    entries.push(entryFile);
+                }
+
+                // Loop through all inputs to aggregate dependencies and dependents.
+                for (const input of inputs) {
+                    const metaFile = references.inputs.meta[input.filepath];
+                    if (!metaFile) {
+                        warn(`Could not find metafile's ${input.name}`);
+                        continue;
+                    }
+
+                    for (const dependency of metaFile.imports) {
+                        const dependencyPath = path.join(cwd, dependency.path);
+                        const dependencyFile = references.inputs.report[dependencyPath];
+
+                        if (!dependencyFile) {
+                            warn(`Could not find input file of ${dependency.path}`);
+                            continue;
+                        }
+
+                        input.dependencies.push(dependencyFile);
+                        // Add itself to the dependency's dependents.
+                        dependencyFile.dependents.push(input);
+                    }
+                }
+
+                context.build.outputs = outputs;
+                context.build.inputs = inputs;
+                context.build.entries = entries;
+            });
+        },
+    };
+};