ci: Re-add size limit action

mydea · mydea · commit ca83c4d6098c · 2024-03-15T08:12:25.000Z
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -278,6 +278,36 @@ jobs:
       # `job_build` can't see `job_install_deps` and what it returned)
       dependency_cache_key: ${{ needs.job_install_deps.outputs.dependency_cache_key }}
 
+  job_size_check:
+    name: Size Check
+    needs: [job_get_metadata, job_build]
+    timeout-minutes: 15
+    runs-on: ubuntu-20.04
+    if:
+      github.event_name == 'pull_request' || needs.job_get_metadata.outputs.is_develop == '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:
+          # The size limit action runs `yarn` and `yarn build` when this job is executed on
+          # use Node 14 for now.
+          node-version: '14'
+      - name: Restore caches
+        uses: ./.github/actions/restore-cache
+        env:
+          DEPENDENCY_CACHE_KEY: ${{ needs.job_build.outputs.dependency_cache_key }}
+      - name: Check bundle sizes
+        uses: ./dev-packages/size-limit-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
diff --git a/dev-packages/size-limit-gh-action/.eslintrc.cjs b/dev-packages/size-limit-gh-action/.eslintrc.cjs
@@ -0,0 +1,14 @@
+module.exports = {
+  extends: ['../../.eslintrc.js'],
+  parserOptions: {
+    sourceType: 'module',
+    ecmaVersion: 'latest',
+  },
+
+  overrides: [
+    {
+      files: ['*.mjs'],
+      extends: ['@sentry-internal/sdk/src/base'],
+    },
+  ],
+};
diff --git a/dev-packages/size-limit-gh-action/action.yml b/dev-packages/size-limit-gh-action/action.yml
@@ -0,0 +1,17 @@
+name: 'size-limit-gh-action'
+description: 'Run size-limit 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: "0.0125"
+    description: "The percentage threshold for size changes before posting a comment"
+runs:
+  using: 'node20'
+  main: 'index.mjs'
diff --git a/dev-packages/size-limit-gh-action/index.mjs b/dev-packages/size-limit-gh-action/index.mjs
@@ -0,0 +1,296 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import * as artifact 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 bytes from 'bytes';
+import { markdownTable } from 'markdown-table';
+
+import download from 'github-fetch-workflow-artifact';
+
+const SIZE_LIMIT_HEADING = '## size-limit report 📦 ';
+const ARTIFACT_NAME = 'size-limit-action';
+const RESULTS_FILE = 'size-limit-results.json';
+
+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(SIZE_LIMIT_HEADING));
+  return !sizeLimitComment ? null : sizeLimitComment;
+}
+
+async function run() {
+  const { getInput, setFailed } = core;
+
+  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 limit = new SizeLimit();
+    const artifactClient = artifact.create();
+    const resultsFilePath = path.resolve(__dirname, RESULTS_FILE);
+
+    // If we have no comparison branch, we just run size limit & store the result as artifact
+    if (!comparisonBranch) {
+      let base;
+      const { output: baseOutput } = await execSizeLimit();
+
+      try {
+        base = limit.parseResults(baseOutput);
+      } catch (error) {
+        core.error('Error parsing size-limit output. The output should be a json.');
+        throw error;
+      }
+
+      try {
+        await fs.writeFile(resultsFilePath, JSON.stringify(base), 'utf8');
+      } catch (err) {
+        core.error(err);
+      }
+      const globber = await glob.create(resultsFilePath, {
+        followSymbolicLinks: false,
+      });
+      const files = await globber.glob();
+
+      await artifactClient.uploadArtifact(ARTIFACT_NAME, files, __dirname);
+
+      return;
+    }
+
+    // Else, we run size limit for the current branch, AND fetch it for the comparison branch
+    let base;
+    let current;
+
+    try {
+      // Ignore failures here as it is likely that this only happens when introducing size-limit
+      // and this has not been run on the main branch yet
+      await download(octokit, {
+        ...repo,
+        artifactName: ARTIFACT_NAME,
+        branch: comparisonBranch,
+        downloadPath: __dirname,
+        workflowEvent: 'push',
+        workflowName: `${process.env.GITHUB_WORKFLOW || ''}`,
+      });
+      base = JSON.parse(await fs.readFile(resultsFilePath, { encoding: 'utf8' }));
+    } catch (error) {
+      core.startGroup('Warning, unable to find base results');
+      core.debug(error);
+      core.endGroup();
+    }
+
+    const { status, output } = await execSizeLimit();
+    try {
+      current = limit.parseResults(output);
+    } catch (error) {
+      core.error('Error parsing size-limit output. The output should be a json.');
+      throw error;
+    }
+
+    const thresholdNumber = Number(threshold);
+
+    // @ts-ignore
+    const sizeLimitComment = await fetchPreviousComment(octokit, repo, pr);
+
+    const shouldComment =
+      isNaN(thresholdNumber) || limit.hasSizeChanges(base, current, thresholdNumber) || sizeLimitComment;
+
+    if (shouldComment) {
+      const body = [SIZE_LIMIT_HEADING, markdownTable(limit.formatResults(base, current))].join('\r\n');
+
+      try {
+        if (!sizeLimitComment) {
+          await octokit.rest.issues.createComment({
+            ...repo,
+            // eslint-disable-next-line camelcase
+            issue_number: pr.number,
+            body,
+          });
+        } else {
+          await octokit.rest.issues.updateComment({
+            ...repo,
+            // eslint-disable-next-line camelcase
+            comment_id: sizeLimitComment.id,
+            body,
+          });
+        }
+      } catch (error) {
+        core.error(
+          "Error updating comment. This can happen for PR's originating from a fork without write permissions.",
+        );
+      }
+    }
+
+    if (status > 0) {
+      setFailed('Size limit has been exceeded.');
+    }
+  } catch (error) {
+    core.error(error);
+    setFailed(error.message);
+  }
+}
+
+run();
+
+async function execSizeLimit() {
+  let output = '';
+
+  const status = await exec('yarn', ['size-limit', '--json'], {
+    ignoreReturnCode: true,
+    listeners: {
+      stdout: data => {
+        output += data.toString();
+      },
+    },
+  });
+
+  return { status, output };
+}
+
+const SIZE_RESULTS_HEADER = ['Path', 'Size'];
+const TIME_RESULTS_HEADER = ['Path', 'Size', 'Loading time (3g)', 'Running time (snapdragon)', 'Total time'];
+
+class SizeLimit {
+  formatBytes(size) {
+    return bytes.format(size, { unitSeparator: ' ' });
+  }
+
+  formatTime(seconds) {
+    if (seconds >= 1) {
+      return `${Math.ceil(seconds * 10) / 10} s`;
+    }
+
+    return `${Math.ceil(seconds * 1000)} ms`;
+  }
+
+  formatChange(base = 0, current = 0) {
+    if (base === 0) {
+      return 'added';
+    }
+
+    if (current === 0) {
+      return 'removed';
+    }
+
+    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 `${formatted}%`;
+    }
+
+    return `${formatted}% 🔽`;
+  }
+
+  formatLine(value, change) {
+    return `${value} (${change})`;
+  }
+
+  formatSizeResult(name, base, current) {
+    return [name, this.formatLine(this.formatBytes(current.size), this.formatChange(base.size, current.size))];
+  }
+
+  formatTimeResult(name, base, current) {
+    return [
+      name,
+      this.formatLine(this.formatBytes(current.size), this.formatChange(base.size, current.size)),
+      this.formatLine(this.formatTime(current.loading), this.formatChange(base.loading, current.loading)),
+      this.formatLine(this.formatTime(current.running), this.formatChange(base.running, current.running)),
+      this.formatTime(current.total),
+    ];
+  }
+
+  parseResults(output) {
+    const results = JSON.parse(output);
+
+    return results.reduce((current, result) => {
+      let time = {};
+
+      if (result.loading !== undefined && result.running !== undefined) {
+        const loading = +result.loading;
+        const running = +result.running;
+
+        time = {
+          running,
+          loading,
+          total: loading + running,
+        };
+      }
+
+      return {
+        // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+        ...current,
+        [result.name]: {
+          name: result.name,
+          size: +result.size,
+          ...time,
+        },
+      };
+    }, {});
+  }
+
+  hasSizeChanges(base, current, threshold = 0) {
+    const names = [...new Set([...(base ? Object.keys(base) : []), ...Object.keys(current)])];
+    const isSize = names.some(name => current[name] && current[name].total === undefined);
+
+    // Always return true if time results are present
+    if (!isSize) {
+      return true;
+    }
+
+    return !!names.find(name => {
+      const baseResult = base?.[name] || EmptyResult;
+      const currentResult = current[name] || EmptyResult;
+
+      if (baseResult.size === 0 && currentResult.size === 0) {
+        return true;
+      }
+
+      return Math.abs((currentResult.size - baseResult.size) / baseResult.size) * 100 > threshold;
+    });
+  }
+
+  formatResults(base, current) {
+    const names = [...new Set([...(base ? Object.keys(base) : []), ...Object.keys(current)])];
+    const isSize = names.some(name => current[name] && current[name].total === undefined);
+    const header = isSize ? SIZE_RESULTS_HEADER : TIME_RESULTS_HEADER;
+    const fields = names.map(name => {
+      const baseResult = base?.[name] || EmptyResult;
+      const currentResult = current[name] || EmptyResult;
+
+      if (isSize) {
+        return this.formatSizeResult(name, baseResult, currentResult);
+      }
+      return this.formatTimeResult(name, baseResult, currentResult);
+    });
+
+    return [header, ...fields];
+  }
+}
+
+const EmptyResult = {
+  name: '-',
+  size: 0,
+  running: 0,
+  loading: 0,
+  total: 0,
+};
diff --git a/dev-packages/size-limit-gh-action/package.json b/dev-packages/size-limit-gh-action/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@sentry-internal/size-limit-gh-action",
+  "version": "8.0.0-alpha.2",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.18"
+  },
+  "private": true,
+  "main": "index.mjs",
+  "type": "module",
+  "scripts": {
+    "lint": "eslint . --format stylish",
+    "fix": "eslint . --format stylish --fix"
+  },
+  "dependencies": {
+    "@actions/core": "1.10.1",
+    "@actions/exec": "1.1.1",
+    "@actions/github": "6.0.0",
+    "@actions/artifact": "2.1.4",
+    "@actions/glob": "0.4.0",
+    "markdown-table": "3.0.3",
+    "github-fetch-workflow-artifact": "2.0.0",
+    "bytes": "3.1.2"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/package.json b/package.json
diff --git a/yarn.lock b/yarn.lock
