ci: Capture overhead in node app

.github/workflows/build.yml

@@ -253,6 +253,34 @@ jobs:
           # Only run comparison against develop if this is a PR
           comparison_branch: ${{ (github.event_name == 'pull_request' && github.base_ref) ||  ''}}
 
+  job_node_overhead_check:
+    name: Node Overhead
+    needs: [job_get_metadata, job_build]
+    timeout-minutes: 15
+    runs-on: ubuntu-24.04
+    if:
+      (needs.job_build.outputs.changed_node == 'true' && github.event_name == 'pull_request') ||
+      needs.job_get_metadata.outputs.is_base_branch == 'true' || needs.job_get_metadata.outputs.is_release == 'true'
+    steps:
+      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ env.HEAD_COMMIT }}
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: 'package.json'
+      - name: Restore caches
+        uses: ./.github/actions/restore-cache
+        with:
+          dependency_cache_key: ${{ needs.job_build.outputs.dependency_cache_key }}
+      - name: Check node overhead
+        uses: ./dev-packages/node-overhead-gh-action
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          # Only run comparison against develop if this is a PR
+          comparison_branch: ${{ (github.event_name == 'pull_request' && github.base_ref) ||  ''}}
+
   job_lint:
     name: Lint
     # Even though the linter only checks source code, not built code, it needs the built code in order check that all

dev-packages/node-overhead-gh-action/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  env: {
+    node: true,
+  },
+  extends: ['../../.eslintrc.js'],
+  overrides: [
+    {
+      files: ['src/**/*.mjs', 'lib/**/*.mjs'],
+      parserOptions: {
+        project: ['tsconfig.json'],
+        sourceType: 'module',
+      },
+    },
+  ],
+};

dev-packages/node-overhead-gh-action/README.md

@@ -0,0 +1,3 @@
+# node-overhead-gh-action
+
+Capture the overhead of Sentry in a node app.

dev-packages/node-overhead-gh-action/action.yml

@@ -0,0 +1,17 @@
+name: 'node-overhead-gh-action'
+description: 'Run node overhead comparison'
+inputs:
+  github_token:
+    required: true
+    description: 'a github access token'
+  comparison_branch:
+    required: false
+    default: ''
+    description: 'If set, compare the current branch with this branch'
+  threshold:
+    required: false
+    default: '3'
+    description: 'The percentage threshold for size changes before posting a comment'
+runs:
+  using: 'node24'
+  main: 'index.mjs'

dev-packages/node-overhead-gh-action/index.mjs

@@ -0,0 +1,226 @@
+/* eslint-disable complexity */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DefaultArtifactClient } from '@actions/artifact';
+import * as core from '@actions/core';
+import { exec } from '@actions/exec';
+import { context, getOctokit } from '@actions/github';
+import * as glob from '@actions/glob';
+import * as io from '@actions/io';
+import { markdownTable } from 'markdown-table';
+import { getOverheadMeasurements } from './lib/getOverheadMeasurements.mjs';
+import { Formatter } from './lib/Formatter.mjs';
+
+const NODE_OVERHEAD_HEADING = '## node-overhead report 📦 ';
+const ARTIFACT_NAME = 'node-overhead-action';
+const RESULTS_FILE = 'node-overhead-results.json';
+
+function getResultsFilePath() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(__dirname, RESULTS_FILE);
+}
+
+const { getInput, setFailed } = core;
+
+async function fetchPreviousComment(octokit, repo, pr) {
+  const { data: commentList } = await octokit.rest.issues.listComments({
+    ...repo,
+    issue_number: pr.number,
+  });
+
+  const sizeLimitComment = commentList.find(comment => comment.body.startsWith(NODE_OVERHEAD_HEADING));
+  return !sizeLimitComment ? null : sizeLimitComment;
+}
+
+async function run() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+  try {
+    const { payload, repo } = context;
+    const pr = payload.pull_request;
+
+    const comparisonBranch = getInput('comparison_branch');
+    const githubToken = getInput('github_token');
+    const threshold = getInput('threshold');
+
+    if (comparisonBranch && !pr) {
+      throw new Error('No PR found. Only pull_request workflows are supported.');
+    }
+
+    const octokit = getOctokit(githubToken);
+    const resultsFilePath = getResultsFilePath();
+    const formatter = new Formatter();
+
+    // If we have no comparison branch, we just run size limit & store the result as artifact
+    if (!comparisonBranch) {
+      return runNodeOverheadOnComparisonBranch();
+    }
+
+    // Else, we run size limit for the current branch, AND fetch it for the comparison branch
+    let base;
+    let current;
+    let baseIsNotLatest = false;
+    let baseWorkflowRun;
+
+    try {
+      const workflowName = `${process.env.GITHUB_WORKFLOW || ''}`;
+      core.startGroup(`getArtifactsForBranchAndWorkflow - workflow:"${workflowName}",  branch:"${comparisonBranch}"`);
+      const artifacts = await getArtifactsForBranchAndWorkflow(octokit, {
+        ...repo,
+        artifactName: ARTIFACT_NAME,
+        branch: comparisonBranch,
+        workflowName,
+      });
+      core.endGroup();
+
+      if (!artifacts) {
+        throw new Error('No artifacts found');
+      }
+
+      baseWorkflowRun = artifacts.workflowRun;
+
+      await downloadOtherWorkflowArtifact(octokit, {
+        ...repo,
+        artifactName: ARTIFACT_NAME,
+        artifactId: artifacts.artifact.id,
+        downloadPath: __dirname,
+      });
+
+      base = JSON.parse(await fs.readFile(resultsFilePath, { encoding: 'utf8' }));
+
+      if (!artifacts.isLatest) {
+        baseIsNotLatest = true;
+        core.info('Base artifact is not the latest one. This may lead to incorrect results.');
+      }
+    } catch (error) {
+      core.startGroup('Warning, unable to find base results');
+      core.error(error);
+      core.endGroup();
+    }
+
+    current = await getOverheadMeasurements();
+    const thresholdNumber = Number(threshold);
+
+    const nodeOverheadComment = await fetchPreviousComment(octokit, repo, pr);
+
+    if (nodeOverheadComment) {
+      core.debug('Found existing node overhead comment, updating it instead of creating a new one...');
+    }
+
+    const shouldComment =
+      isNaN(thresholdNumber) || formatter.hasSizeChanges(base, current, thresholdNumber) || nodeOverheadComment;
+
+    if (shouldComment) {
+      const bodyParts = [NODE_OVERHEAD_HEADING];
+
+      if (baseIsNotLatest) {
+        bodyParts.push(
+          '⚠️ **Warning:** Base artifact is not the latest one, because the latest workflow run is not done yet. This may lead to incorrect results. Try to re-run all tests to get up to date results.',
+        );
+      }
+      try {
+        bodyParts.push(markdownTable(formatter.formatResults(base, current)));
+      } catch (error) {
+        core.error('Error generating markdown table');
+        core.error(error);
+      }
+
+      if (baseWorkflowRun) {
+        bodyParts.push('');
+        bodyParts.push(`[View base workflow run](${baseWorkflowRun.html_url})`);
+      }
+
+      const body = bodyParts.join('\r\n');
+
+      try {
+        if (!nodeOverheadComment) {
+          await octokit.rest.issues.createComment({
+            ...repo,
+            issue_number: pr.number,
+            body,
+          });
+        } else {
+          await octokit.rest.issues.updateComment({
+            ...repo,
+            comment_id: nodeOverheadComment.id,
+            body,
+          });
+        }
+      } catch (error) {
+        core.error(
+          "Error updating comment. This can happen for PR's originating from a fork without write permissions.",
+        );
+      }
+    } else {
+      core.debug('Skipping comment because there are no changes.');
+    }
+  } catch (error) {
+    core.error(error);
+    setFailed(error.message);
+  }
+}
+
+async function runNodeOverheadOnComparisonBranch() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const resultsFilePath = getResultsFilePath();
+
+  const artifactClient = new DefaultArtifactClient();
+
+  const result = await getOverheadMeasurements();
+
+  try {
+    await fs.writeFile(resultsFilePath, JSON.stringify(result), 'utf8');
+  } catch (error) {
+    core.error('Error parsing node overhead output. The output should be a json.');
+    throw error;
+  }
+
+  const globber = await glob.create(resultsFilePath, {
+    followSymbolicLinks: false,
+  });
+  const files = await globber.glob();
+
+  await artifactClient.uploadArtifact(ARTIFACT_NAME, files, __dirname);
+}
+
+run();
+
+/**
+ * Use GitHub API to fetch artifact download url, then
+ * download and extract artifact to `downloadPath`
+ */
+async function downloadOtherWorkflowArtifact(octokit, { owner, repo, artifactId, artifactName, downloadPath }) {
+  const artifact = await octokit.rest.actions.downloadArtifact({
+    owner,
+    repo,
+    artifact_id: artifactId,
+    archive_format: 'zip',
+  });
+
+  // Make sure output path exists
+  try {
+    await io.mkdirP(downloadPath);
+  } catch {
+    // ignore errors
+  }
+
+  const downloadFile = path.resolve(downloadPath, `${artifactName}.zip`);
+
+  await exec('wget', [
+    '-nv',
+    '--retry-connrefused',
+    '--waitretry=1',
+    '--read-timeout=20',
+    '--timeout=15',
+    '-t',
+    '0',
+    '-O',
+    downloadFile,
+    artifact.url,
+  ]);
+
+  await exec('unzip', ['-q', '-d', downloadPath, downloadFile], {
+    silent: true,
+  });
+}

dev-packages/node-overhead-gh-action/lib/Formatter.mjs

@@ -0,0 +1,61 @@
+import * as core from '@actions/core';
+import bytes from 'bytes-iec';
+
+const NODE_OVERHEAD_RESULTS_HEADER = ['Scenario', 'Prev Requests/s', 'New Requests/s', 'Change %'];
+
+export class Formatter {
+  formatPercentageChange(base = 0, current = 0) {
+    const value = ((current - base) / base) * 100;
+    const formatted = (Math.sign(value) * Math.ceil(Math.abs(value) * 100)) / 100;
+
+    if (value > 0) {
+      return `+${formatted}%`;
+    }
+
+    if (value === 0) {
+      return '-';
+    }
+
+    return `${formatted}%`;
+  }
+
+  formatSizeResult(name, base, current) {
+    if (!current.passed) {
+      core.debug(
+        `Size limit exceeded for ${name} - ${this.formatBytes(current.size)} > ${this.formatBytes(current.sizeLimit)}`,
+      );
+    }
+
+    return [name, base, current, this.formatPercentageChange(base, current)];
+  }
+
+  hasSizeChanges(base, current, threshold = 0) {
+    if (!base || !current) {
+      return true;
+    }
+
+    const names = ['baseline', 'withInstrument', 'withInstrumentErrorOnly'];
+
+    return names.some(name => {
+      const baseResult = base[name];
+      const currentResult = current[name];
+
+      if (!baseResult || !currentResult) {
+        return true;
+      }
+
+      return Math.abs((currentResult.size - baseResult.size) / baseResult.size) * 100 > threshold;
+    });
+  }
+
+  formatResults(base, current) {
+    const headers = NODE_OVERHEAD_RESULTS_HEADER;
+
+    return [
+      headers,
+      this.formatSizeResult('Baseline', base.baseline, current.baseline),
+      this.formatSizeResult('With Sentry', base.withInstrument, current.withInstrument),
+      this.formatSizeResult('With Sentry (error only)', base.withInstrumentErrorOnly, current.withInstrumentErrorOnly),
+    ];
+  }
+}