Merge aa16bdbbcb into 070b78a040

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

docs/usage/mend-hosted/hosted-apps-config.md

@@ -74,12 +74,12 @@ This change causes Renovate to create an Onboarding PR, even if Renovate does no
 
 ## Fork Processing
 
-If an Organization installs Renovate with the "All repositories" option, then `forkProcessing` will remain set to its default value `false`.
+If an Organization installs Renovate with the "All repositories" option, then `forkProcessing` will remain set to its default value `disabled`.
 This means forked repositories are _not_ onboarded, Renovate ignores them.
-To change this behavior, push a `renovate.json` file to the repository with `"forkProcessing": true`.
+To change this behavior, push a `renovate.json` file to the repository with `"forkProcessing": "enabled"`.
 
 If an Organization installs Renovate with "Selected repositories", we assume the organization wants to onboard _all_ of the selected repositories, even forked repositories.
-Therefore we set `forkProcessing` to `true`.
+Therefore we set `forkProcessing` to "enabled".
 
 ## Inherited config
 

lib/config/types.ts

@@ -271,6 +271,7 @@ export interface RenovateConfig
   packageFile?: string;
   packageRules?: PackageRule[];
   postUpdateOptions?: string[];
+  branchConcurrentLimit?: number | null;
   prConcurrentLimit?: number;
   prHourlyLimit?: number;
   forkModeDisallowMaintainerEdits?: boolean;

lib/data/replacements.json

@@ -23,6 +23,7 @@
       "replacements:k8s-registry-move",
       "replacements:mem-rename",
       "replacements:middie-to-scoped",
+      "replacements:netflix-dgs-spring-starters",
       "replacements:now-to-vercel",
       "replacements:npm-run-all-to-maintenance-fork",
       "replacements:opencost-registry-move",
@@ -751,6 +752,21 @@
       }
     ]
   },
+  "netflix-dgs-spring-starters": {
+    "description": "`dgs-framework` migrated to new `spring-graphql` starters.",
+    "packageRules": [
+      {
+        "matchCurrentVersion": "[9.2.2,)",
+        "matchDatasources": ["maven"],
+        "matchPackageNames": [
+          "com.netflix.graphql.dgs:graphql-dgs-spring-boot-starter",
+          "com.netflix.graphql.dgs:graphql-dgs-webflux-starter"
+        ],
+        "replacementName": "com.netflix.graphql.dgs:dgs-starter",
+        "replacementVersion": "10.0.1"
+      }
+    ]
+  },
   "now-to-vercel": {
     "description": "`now` was renamed to `vercel`.",
     "packageRules": [

lib/modules/manager/bundler/artifacts.spec.ts

@@ -679,71 +679,6 @@ describe('modules/manager/bundler/artifacts', () => {
         ]);
       });
 
-      it('handles failure of strict updating for version solving', async () => {
-        const execError = new ExecError('Exec error', {
-          cmd: '',
-          stdout: '',
-          stderr: 'version solving has failed',
-          options: { encoding: 'utf8' },
-        });
-        fs.readLocalFile.mockResolvedValue('Current Gemfile.lock');
-        const execSnapshots = mockExecSequence([
-          execError,
-          { stdout: '', stderr: '' },
-        ]);
-        git.getRepoStatus.mockResolvedValueOnce(
-          partial<StatusResult>({
-            modified: ['Gemfile.lock'],
-          }),
-        );
-
-        const res = await updateArtifacts({
-          packageFileName: 'Gemfile',
-          updatedDeps: [{ depName: 'foo', updateType: 'minor' }],
-          newPackageFileContent: '{}',
-          config,
-        });
-
-        expect(res).toMatchObject([{ file: { path: 'Gemfile.lock' } }]);
-        expect(execSnapshots).toMatchObject([
-          { cmd: 'bundler lock --minor --strict --update foo' },
-          { cmd: 'bundler lock --minor --conservative --update foo' },
-        ]);
-      });
-
-      it('handles failure of strict updating for missing gem', async () => {
-        // See https://github.com/rubygems/rubygems/issues/7369
-        const execError = new ExecError('Exec error', {
-          cmd: '',
-          stdout: '',
-          stderr: "Could not find gems matching 'foo ",
-          options: { encoding: 'utf8' },
-        });
-        fs.readLocalFile.mockResolvedValue('Current Gemfile.lock');
-        const execSnapshots = mockExecSequence([
-          execError,
-          { stdout: '', stderr: '' },
-        ]);
-        git.getRepoStatus.mockResolvedValueOnce(
-          partial<StatusResult>({
-            modified: ['Gemfile.lock'],
-          }),
-        );
-
-        const res = await updateArtifacts({
-          packageFileName: 'Gemfile',
-          updatedDeps: [{ depName: 'foo', updateType: 'minor' }],
-          newPackageFileContent: '{}',
-          config,
-        });
-
-        expect(res).toMatchObject([{ file: { path: 'Gemfile.lock' } }]);
-        expect(execSnapshots).toMatchObject([
-          { cmd: 'bundler lock --minor --strict --update foo' },
-          { cmd: 'bundler lock --minor --conservative --update foo' },
-        ]);
-      });
-
       it('updates the Gemfile.lock when upgrading ruby', async () => {
         // See https://github.com/renovatebot/renovate/issues/15114
         fs.readLocalFile.mockResolvedValue('Current Gemfile.lock');

lib/modules/manager/bundler/artifacts.ts

@@ -105,8 +105,8 @@ export async function updateArtifacts(
       }
 
       const updateTypes = {
-        patch: '--patch --strict ',
-        minor: '--minor --strict ',
+        patch: '--patch ',
+        minor: '--minor ',
         major: '',
       };
       for (const [updateType, updateArg] of Object.entries(updateTypes)) {
@@ -120,12 +120,9 @@ export async function updateArtifacts(
           additionalArgs = '--conservative ';
         }
         if (deps.length) {
-          let cmd = `bundler lock ${updateArg}${additionalArgs}--update ${deps
+          const cmd = `bundler lock ${updateArg}${additionalArgs}--update ${deps
             .map(quote)
             .join(' ')}`;
-          if (cmd.includes(' --conservative ')) {
-            cmd = cmd.replace(' --strict', '');
-          }
           commands.push(cmd);
         }
       }
@@ -226,29 +223,6 @@ export async function updateArtifacts(
       memCache.set('bundlerArtifactsError', BUNDLER_INVALID_CREDENTIALS);
       throw new Error(BUNDLER_INVALID_CREDENTIALS);
     }
-    if (
-      recursionLimit > 0 &&
-      (output.includes('version solving has failed') ||
-        output.includes('Could not find gem'))
-    ) {
-      logger.debug('Failed to lock strictly, retrying non-strict');
-      const newConfig = {
-        ...config,
-        postUpdateOptions: [
-          ...(config.postUpdateOptions ?? []),
-          'bundlerConservative',
-        ],
-      };
-      return updateArtifacts(
-        {
-          packageFileName,
-          updatedDeps,
-          newPackageFileContent,
-          config: newConfig,
-        },
-        recursionLimit - 1,
-      );
-    }
     const resolveMatches: string[] = getResolvedPackages(output).filter(
       (depName) => !updatedDepNames.includes(depName),
     );

lib/workers/global/limits.spec.ts

@@ -1,7 +1,13 @@
+import { partial } from '../../../test/util';
+import type { BranchConfig, BranchUpgradeConfig } from '../types';
 import {
+  calcLimit,
+  hasMultipleLimits,
+  incCountValue,
   incLimitedValue,
   isLimitReached,
   resetAllLimits,
+  setCount,
   setMaxLimit,
 } from './limits';
 
@@ -60,4 +66,242 @@ describe('workers/global/limits', () => {
     setMaxLimit('Commits', -1000);
     expect(isLimitReached('Commits')).toBeTrue();
   });
+
+  describe('calcLimit', () => {
+    it('handles single upgrade', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+      ]);
+
+      expect(calcLimit(upgrades, 'prHourlyLimit')).toBe(10);
+      expect(calcLimit(upgrades, 'branchConcurrentLimit')).toBe(11);
+      expect(calcLimit(upgrades, 'prConcurrentLimit')).toBe(12);
+    });
+
+    it('inherits prConcurrentLimit if branchConcurrentLimit is null', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: 12,
+        },
+      ]);
+
+      expect(calcLimit(upgrades, 'prHourlyLimit')).toBe(10);
+      expect(calcLimit(upgrades, 'branchConcurrentLimit')).toBe(12);
+      expect(calcLimit(upgrades, 'prConcurrentLimit')).toBe(12);
+    });
+
+    it('returns 0 if atleast one upgrade has no limit in the branch', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 0,
+          branchConcurrentLimit: 0,
+          prConcurrentLimit: 0,
+        },
+        {
+          prHourlyLimit: 1,
+          branchConcurrentLimit: 1,
+          prConcurrentLimit: 1,
+        },
+      ]);
+
+      expect(calcLimit(upgrades, 'prHourlyLimit')).toBe(0);
+      expect(calcLimit(upgrades, 'branchConcurrentLimit')).toBe(0);
+      expect(calcLimit(upgrades, 'prConcurrentLimit')).toBe(0);
+    });
+
+    it('computes the lowest limit if multiple limits are present', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 1,
+          branchConcurrentLimit: 1,
+          prConcurrentLimit: 1,
+        },
+        {
+          prHourlyLimit: 5,
+          branchConcurrentLimit: 6,
+          prConcurrentLimit: 3,
+        },
+        {
+          prHourlyLimit: 5,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: undefined,
+        },
+        {
+          prHourlyLimit: 5,
+          branchConcurrentLimit: 6,
+          prConcurrentLimit: 2,
+        },
+      ]);
+
+      expect(calcLimit(upgrades, 'prHourlyLimit')).toBe(1);
+      expect(calcLimit(upgrades, 'branchConcurrentLimit')).toBe(1);
+      expect(calcLimit(upgrades, 'prConcurrentLimit')).toBe(1);
+    });
+  });
+
+  describe('hasMultipleLimits', () => {
+    it('handles single limit', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+      ]);
+      expect(hasMultipleLimits(upgrades, 'prHourlyLimit')).toBe(false);
+      expect(hasMultipleLimits(upgrades, 'branchConcurrentLimit')).toBe(false);
+      expect(hasMultipleLimits(upgrades, 'prConcurrentLimit')).toBe(false);
+    });
+
+    it('returns false if there are multiple limits with value', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+      ]);
+      expect(hasMultipleLimits(upgrades, 'prHourlyLimit')).toBe(false);
+      expect(hasMultipleLimits(upgrades, 'branchConcurrentLimit')).toBe(false);
+      expect(hasMultipleLimits(upgrades, 'prConcurrentLimit')).toBe(false);
+    });
+
+    it('handles multiple limits', () => {
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 11,
+          branchConcurrentLimit: 12,
+          prConcurrentLimit: 13,
+        },
+        {
+          prHourlyLimit: 0,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: 3,
+        },
+      ]);
+      expect(hasMultipleLimits(upgrades, 'prHourlyLimit')).toBe(true);
+      expect(hasMultipleLimits(upgrades, 'branchConcurrentLimit')).toBe(true);
+      expect(hasMultipleLimits(upgrades, 'prConcurrentLimit')).toBe(true);
+    });
+  });
+
+  describe('isLimitReached', () => {
+    it('returns false based on concurrent limits', () => {
+      setCount('ConcurrentPRs', 1);
+      setCount('HourlyPRs', 1);
+      incCountValue('Branches'); // using incCountValue so it gets test coverage
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 11,
+          branchConcurrentLimit: 12,
+          prConcurrentLimit: 13,
+        },
+        {
+          prHourlyLimit: 0,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: 3,
+        },
+      ]);
+      expect(
+        isLimitReached('Branches', partial<BranchConfig>({ upgrades })),
+      ).toBe(false);
+      expect(
+        isLimitReached('ConcurrentPRs', partial<BranchConfig>({ upgrades })),
+      ).toBe(false);
+    });
+
+    it('returns true when hourly limit is reached', () => {
+      setCount('Branches', 2);
+      setCount('ConcurrentPRs', 2);
+      setCount('HourlyPRs', 2);
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 11,
+          branchConcurrentLimit: 12,
+          prConcurrentLimit: 13,
+        },
+        {
+          prHourlyLimit: 2,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: 3,
+        },
+      ]);
+      expect(
+        isLimitReached('Branches', partial<BranchConfig>({ upgrades })),
+      ).toBe(true);
+      expect(
+        isLimitReached('ConcurrentPRs', partial<BranchConfig>({ upgrades })),
+      ).toBe(true);
+    });
+
+    it('returns true when concurrent limit is reached', () => {
+      setCount('Branches', 3);
+      setCount('ConcurrentPRs', 3);
+      setCount('HourlyPRs', 4);
+      const upgrades = partial<BranchUpgradeConfig>([
+        {
+          prHourlyLimit: 10,
+          branchConcurrentLimit: 11,
+          prConcurrentLimit: 12,
+        },
+        {
+          prHourlyLimit: 11,
+          branchConcurrentLimit: 12,
+          prConcurrentLimit: 13,
+        },
+        {
+          prHourlyLimit: 5,
+          branchConcurrentLimit: null,
+          prConcurrentLimit: 3,
+        },
+      ]);
+      expect(
+        isLimitReached('Branches', partial<BranchConfig>({ upgrades })),
+      ).toBe(true);
+      expect(
+        isLimitReached('ConcurrentPRs', partial<BranchConfig>({ upgrades })),
+      ).toBe(true);
+    });
+  });
 });

lib/workers/global/limits.ts

@@ -1,7 +1,8 @@
+import is from '@sindresorhus/is';
 import { logger } from '../../logger';
+import type { BranchConfig, BranchUpgradeConfig } from '../types';
 
-export type Limit = 'Commits' | 'PullRequests' | 'Branches';
-
+export type Limit = 'Commits';
 interface LimitValue {
   max: number | null;
   current: number;
@@ -27,8 +28,8 @@ export function incLimitedValue(key: Limit, incBy = 1): void {
   });
 }
 
-export function isLimitReached(key: Limit): boolean {
-  const limit = limits.get(key);
+function handleCommitsLimit(): boolean {
+  const limit = limits.get('Commits');
   // TODO: fix me?
   // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
   if (!limit || limit.max === null) {
@@ -37,3 +38,162 @@ export function isLimitReached(key: Limit): boolean {
   const { max, current } = limit;
   return max - current <= 0;
 }
+
+export type CountName = 'ConcurrentPRs' | 'HourlyPRs' | 'Branches';
+
+type BranchLimitName =
+  | 'branchConcurrentLimit'
+  | 'prConcurrentLimit'
+  | 'prHourlyLimit';
+
+export const counts = new Map<CountName, number>();
+
+export function getCount(key: CountName): number {
+  const count = counts.get(key);
+  // istanbul ignore if: should not happen
+  if (!count) {
+    logger.warn(`Could not compute the count of ${key}, returning zero.`);
+    return 0;
+  }
+  return count;
+}
+
+export function setCount(key: CountName, val: number): void {
+  counts.set(key, val);
+  logger.debug(`${key} count = ${val}`);
+}
+
+export function incCountValue(key: CountName, incBy = 1): void {
+  const count = getCount(key);
+  counts.set(key, count + incBy);
+}
+
+function handleConcurrentLimits(
+  key: Exclude<CountName, 'HourlyPRs'>,
+  config: BranchConfig,
+): boolean {
+  const limitKey =
+    key === 'Branches' ? 'branchConcurrentLimit' : 'prConcurrentLimit';
+
+  // calculate the limits for this branch
+  const hourlyLimit = calcLimit(config.upgrades, 'prHourlyLimit');
+  const hourlyPrCount = getCount('HourlyPRs');
+
+  // if a limit is defined ( >0 ) and limit reached return true ie. limit has been reached
+  if (hourlyLimit && hourlyPrCount >= hourlyLimit) {
+    return true;
+  }
+
+  const limitValue = calcLimit(config.upgrades, limitKey);
+  const currentCount = getCount(key);
+
+  if (limitValue && currentCount >= limitValue) {
+    return true;
+  }
+
+  return false;
+}
+
+export function calcLimit(
+  upgrades: BranchUpgradeConfig[],
+  limitName: BranchLimitName,
+): number {
+  logger.debug(
+    {
+      limits: upgrades.map((upg) => {
+        return { depName: upg.depName, [limitName]: upg[limitName] };
+      }),
+    },
+    `${limitName} of the upgrades present in this branch`,
+  );
+
+  if (hasMultipleLimits(upgrades, limitName)) {
+    logger.once.debug(
+      `Branch has multiple ${limitName} limits. The lowest among these will be selected.`,
+    );
+  }
+
+  let lowestLimit = Number.MAX_SAFE_INTEGER;
+  for (const upgrade of upgrades) {
+    let limit = upgrade[limitName];
+
+    // inherit prConcurrentLimit value incase branchConcurrentLimit is null
+    if (!is.number(limit) && limitName === 'branchConcurrentLimit') {
+      limit = upgrade.prConcurrentLimit;
+    }
+
+    // istanbul ignore if: should never happen as all limits get a default value
+    if (is.undefined(limit)) {
+      limit = Number.MAX_SAFE_INTEGER;
+    }
+
+    // no limit
+    if (limit === 0 || limit === null) {
+      logger.debug(
+        `${limitName} of this branch is unlimited, because atleast one of the upgrade has it's ${limitName} set to "No limit" ie. 0 or null`,
+      );
+      return 0;
+    }
+
+    // limit is set
+    lowestLimit = limit < lowestLimit ? limit : lowestLimit;
+  }
+
+  logger.debug(
+    `Calculated lowest ${limitName} among the upgrades present in this branch is ${lowestLimit}.`,
+  );
+  return lowestLimit;
+}
+
+export function hasMultipleLimits(
+  upgrades: BranchUpgradeConfig[],
+  limitName: BranchLimitName,
+): boolean {
+  if (upgrades.length === 1) {
+    return false;
+  }
+
+  const distinctLimits = new Set<number>();
+  for (const upgrade of upgrades) {
+    let limitValue = upgrade[limitName];
+
+    // inherit prConcurrentLimit value incase branchConcurrentLimit is null
+    if (limitName === 'branchConcurrentLimit' && !is.number(limitValue)) {
+      limitValue = upgrade.prConcurrentLimit;
+    }
+
+    // istanbul ignore if: should not happen as the limits are of type number
+    if (limitValue === null) {
+      limitValue = 0;
+    }
+
+    if (!is.undefined(limitValue) && !distinctLimits.has(limitValue)) {
+      distinctLimits.add(limitValue);
+    }
+  }
+
+  return distinctLimits.size > 1;
+}
+
+export function isLimitReached(limit: 'Commits'): boolean;
+export function isLimitReached(
+  limit: 'Branches' | 'ConcurrentPRs',
+  config: BranchConfig,
+): boolean;
+export function isLimitReached(
+  limit: 'Commits' | 'Branches' | 'ConcurrentPRs',
+  config?: BranchConfig,
+): boolean {
+  if (limit === 'Commits') {
+    return handleCommitsLimit();
+  }
+
+  if (config) {
+    return handleConcurrentLimits(limit, config);
+  }
+
+  // istanbul ignore next: should not happen
+  throw new Error(
+    'Config is required for computing limits for Branches and PullRequests',
+  );
+}

lib/workers/repository/process/limits.spec.ts

@@ -18,8 +18,8 @@ beforeEach(() => {
 });
 
 describe('workers/repository/process/limits', () => {
-  describe('getPrHourlyRemaining()', () => {
-    it('calculates hourly limit remaining', async () => {
+  describe('getPrHourlyCount()', () => {
+    it('calculates hourly pr count', async () => {
       const time = DateTime.local();
       const createdAt = time.toISO();
       platform.getPrList.mockResolvedValueOnce([
@@ -33,30 +33,19 @@ describe('workers/repository/process/limits', () => {
         { createdAt, sourceBranch: 'bar/configure' },
         { createdAt, sourceBranch: 'baz/test' },
       ] as never);
-      const res = await limits.getPrHourlyRemaining({
-        ...config,
-        prHourlyLimit: 10,
-      });
-      expect(res).toBe(7);
+      const res = await limits.getPrHourlyCount(config);
+      expect(res).toBe(3);
     });
 
-    it('returns prHourlyLimit if errored', async () => {
-      config.prHourlyLimit = 5;
+    it('returns zero if errored', async () => {
       platform.getPrList.mockRejectedValue('Unknown error');
-      const res = await limits.getPrHourlyRemaining(config);
-      expect(res).toBe(5);
-    });
-
-    it('returns MAX_SAFE_INTEGER if no hourly limit', async () => {
-      config.prHourlyLimit = 0;
-      const res = await limits.getPrHourlyRemaining(config);
-      expect(res).toBe(Number.MAX_SAFE_INTEGER);
+      const res = await limits.getPrHourlyCount(config);
+      expect(res).toBe(0);
     });
   });
 
-  describe('getConcurrentPrsRemaining()', () => {
-    it('calculates concurrent limit remaining', async () => {
-      config.prConcurrentLimit = 20;
+  describe('getConcurrentPrsCount()', () => {
+    it('calculates concurrent prs present', async () => {
       platform.getBranchPr.mockImplementation((branchName) =>
         branchName
           ? Promise.resolve(
@@ -71,100 +60,21 @@ describe('workers/repository/process/limits', () => {
         { branchName: 'test' },
         { branchName: null },
       ] as never;
-      const res = await limits.getConcurrentPrsRemaining(config, branches);
-      expect(res).toBe(19);
-    });
-
-    it('returns MAX_SAFE_INTEGER if no concurrent limit', async () => {
-      config.prConcurrentLimit = 0;
-      const res = await limits.getConcurrentPrsRemaining(config, []);
-      expect(res).toBe(Number.MAX_SAFE_INTEGER);
-    });
-  });
-
-  describe('getPrsRemaining()', () => {
-    it('returns hourly limit', async () => {
-      config.prHourlyLimit = 1;
-      platform.getPrList.mockResolvedValueOnce([]);
-      const res = await limits.getPrsRemaining(config, []);
-      expect(res).toBe(1);
-    });
-
-    it('returns concurrent limit', async () => {
-      config.prConcurrentLimit = 1;
-      const res = await limits.getPrsRemaining(config, []);
+      const res = await limits.getConcurrentPrsCount(config, branches);
       expect(res).toBe(1);
     });
   });
 
-  describe('getConcurrentBranchesRemaining()', () => {
-    it('calculates concurrent limit remaining', async () => {
-      config.branchConcurrentLimit = 20;
-      scm.branchExists.mockResolvedValueOnce(true);
-      const res = await limits.getConcurrentBranchesRemaining(config, [
-        { branchName: 'foo' },
-      ] as never);
-      expect(res).toBe(19);
-    });
-
-    it('defaults to prConcurrentLimit', async () => {
-      config.branchConcurrentLimit = null;
-      config.prConcurrentLimit = 20;
-      scm.branchExists.mockResolvedValueOnce(true);
-      const res = await limits.getConcurrentBranchesRemaining(config, [
-        { branchName: 'foo' },
-      ] as never);
-      expect(res).toBe(19);
-    });
-
-    it('does not use prConcurrentLimit for explicit branchConcurrentLimit=0', async () => {
-      config.branchConcurrentLimit = 0;
-      config.prConcurrentLimit = 20;
-      const res = await limits.getConcurrentBranchesRemaining(config, []);
-      expect(res).toBe(Number.MAX_SAFE_INTEGER);
-    });
-
-    it('returns 10 if no limits are set', async () => {
-      const res = await limits.getConcurrentBranchesRemaining(config, []);
-      expect(res).toBe(10);
-    });
-
-    it('returns prConcurrentLimit if errored', async () => {
-      config.branchConcurrentLimit = 2;
-      // TODO: #22198
-      const res = await limits.getConcurrentBranchesRemaining(
-        config,
-        null as never,
+  describe('getConcurrentBranchesCount()', () => {
+    it('calculates concurrent branches present', async () => {
+      scm.branchExists.mockImplementation((branchName) =>
+        branchName ? Promise.resolve(true) : Promise.resolve(false),
       );
-      expect(res).toBe(2);
-    });
-  });
-
-  describe('getBranchesRemaining()', () => {
-    it('returns minimal of both limits', async () => {
-      platform.getPrList.mockResolvedValue([]);
-
-      await expect(
-        limits.getBranchesRemaining(
-          {
-            ...config,
-            prHourlyLimit: 3,
-            branchConcurrentLimit: 5,
-          },
-          [],
-        ),
-      ).resolves.toBe(3);
-
-      await expect(
-        limits.getBranchesRemaining(
-          {
-            ...config,
-            prHourlyLimit: 11,
-            branchConcurrentLimit: 7,
-          },
-          [],
-        ),
-      ).resolves.toBe(7);
+      const res = await limits.getConcurrentBranchesCount([
+        { branchName: 'foo' },
+        { branchName: null },
+      ] as never);
+      expect(res).toBe(1);
     });
   });
 });

lib/workers/repository/process/limits.ts

@@ -1,141 +1,79 @@
 import { DateTime } from 'luxon';
 import type { RenovateConfig } from '../../../config/types';
 import { logger } from '../../../logger';
-import type { Pr } from '../../../modules/platform';
 import { platform } from '../../../modules/platform';
 import { scm } from '../../../modules/platform/scm';
 import { ExternalHostError } from '../../../types/errors/external-host-error';
 import type { BranchConfig } from '../../types';
 
-export async function getPrHourlyRemaining(
+export async function getPrHourlyCount(
   config: RenovateConfig,
 ): Promise<number> {
-  if (config.prHourlyLimit) {
+  try {
+    const prList = await platform.getPrList();
+    const currentHourStart = DateTime.local().setZone('utc').startOf('hour');
+    logger.debug(
+      `Calculating PRs created so far in this hour currentHourStart=${String(currentHourStart)}`,
+    );
+    const soFarThisHour = prList.filter(
+      (pr) =>
+        pr.sourceBranch !== config.onboardingBranch &&
+        pr.sourceBranch.startsWith(config.branchPrefix!) &&
+        DateTime.fromISO(pr.createdAt!) > currentHourStart,
+    );
+    logger.debug(
+      `${soFarThisHour.length} PRs have been created so far in this hour.`,
+    );
+    return soFarThisHour.length;
+  } catch (err) {
+    // istanbul ignore if
+    if (err instanceof ExternalHostError) {
+      throw err;
+    }
+    logger.error({ err }, 'Error checking PRs created per hour');
+    return 0;
+  }
+}
+
+export async function getConcurrentPrsCount(
+  config: RenovateConfig,
+  branches: BranchConfig[],
+): Promise<number> {
+  let openPrCount = 0;
+  for (const { branchName } of branches) {
     try {
-      logger.debug('Calculating hourly PRs remaining');
-      const prList = await platform.getPrList();
-      const currentHourStart = DateTime.local().startOf('hour');
-      logger.debug(`currentHourStart=${String(currentHourStart)}`);
-      const soFarThisHour = prList.filter(
-        (pr) =>
-          pr.sourceBranch !== config.onboardingBranch &&
-          pr.sourceBranch.startsWith(config.branchPrefix!) &&
-          DateTime.fromISO(pr.createdAt!) > currentHourStart,
-      );
-      const prsRemaining = Math.max(
-        0,
-        config.prHourlyLimit - soFarThisHour.length,
-      );
-      logger.debug(`PR hourly limit remaining: ${prsRemaining}`);
-      return prsRemaining;
+      const pr = await platform.getBranchPr(branchName, config.baseBranch);
+      if (
+        pr &&
+        pr.sourceBranch !== config.onboardingBranch &&
+        pr.state === 'open'
+      ) {
+        openPrCount++;
+      }
     } catch (err) {
       // istanbul ignore if
       if (err instanceof ExternalHostError) {
         throw err;
+      } else {
+        // no-op
       }
-      logger.error({ err }, 'Error checking PRs created per hour');
-      return config.prHourlyLimit;
     }
   }
-  return Number.MAX_SAFE_INTEGER;
+
+  logger.debug(`${openPrCount} PRs are currently open`);
+  return openPrCount;
 }
 
-export async function getConcurrentPrsRemaining(
-  config: RenovateConfig,
+export async function getConcurrentBranchesCount(
   branches: BranchConfig[],
 ): Promise<number> {
-  if (config.prConcurrentLimit) {
-    logger.debug(`Calculating prConcurrentLimit (${config.prConcurrentLimit})`);
-    try {
-      const openPrs: Pr[] = [];
-      for (const { branchName } of branches) {
-        try {
-          const pr = await platform.getBranchPr(branchName, config.baseBranch);
-          if (
-            pr &&
-            pr.sourceBranch !== config.onboardingBranch &&
-            pr.state === 'open'
-          ) {
-            openPrs.push(pr);
-          }
-        } catch (err) {
-          // istanbul ignore if
-          if (err instanceof ExternalHostError) {
-            throw err;
-          } else {
-            // no-op
-          }
-        }
-      }
-      logger.debug(`${openPrs.length} PRs are currently open`);
-      const concurrentRemaining = Math.max(
-        0,
-        config.prConcurrentLimit - openPrs.length,
-      );
-      logger.debug(`PR concurrent limit remaining: ${concurrentRemaining}`);
-      return concurrentRemaining;
-    } catch (err) /* istanbul ignore next */ {
-      logger.error({ err }, 'Error checking concurrent PRs');
-      return config.prConcurrentLimit;
+  let existingBranchCount = 0;
+  for (const branch of branches) {
+    if (await scm.branchExists(branch.branchName)) {
+      existingBranchCount++;
     }
   }
-  return Number.MAX_SAFE_INTEGER;
-}
-
-export async function getPrsRemaining(
-  config: RenovateConfig,
-  branches: BranchConfig[],
-): Promise<number> {
-  const hourlyRemaining = await getPrHourlyRemaining(config);
-  const concurrentRemaining = await getConcurrentPrsRemaining(config, branches);
-  return Math.min(hourlyRemaining, concurrentRemaining);
-}
-
-export async function getConcurrentBranchesRemaining(
-  config: RenovateConfig,
-  branches: BranchConfig[],
-): Promise<number> {
-  const { branchConcurrentLimit, prConcurrentLimit } = config;
-  const limit =
-    typeof branchConcurrentLimit === 'number'
-      ? branchConcurrentLimit
-      : prConcurrentLimit;
-  if (typeof limit === 'number' && limit) {
-    logger.debug(`Calculating branchConcurrentLimit (${limit})`);
-    try {
-      const existingBranches: string[] = [];
-      for (const branch of branches) {
-        if (await scm.branchExists(branch.branchName)) {
-          existingBranches.push(branch.branchName);
-        }
-      }
-
-      const existingCount = existingBranches.length;
-      logger.debug(
-        `${existingCount} already existing branches found: ${existingBranches.join()}`,
-      );
-
-      const concurrentRemaining = Math.max(0, limit - existingCount);
-      logger.debug(`Branch concurrent limit remaining: ${concurrentRemaining}`);
-
-      return concurrentRemaining;
-    } catch (err) {
-      // TODO: #22198 should never throw
-      logger.error({ err }, 'Error checking concurrent branches');
-      return limit;
-    }
-  }
-  return Number.MAX_SAFE_INTEGER;
-}
-
-export async function getBranchesRemaining(
-  config: RenovateConfig,
-  branches: BranchConfig[],
-): Promise<number> {
-  const hourlyRemaining = await getPrHourlyRemaining(config);
-  const concurrentRemaining = await getConcurrentBranchesRemaining(
-    config,
-    branches,
-  );
-  return Math.min(hourlyRemaining, concurrentRemaining);
+
+  logger.debug(`${existingBranchCount} already existing branches found.`);
+  return existingBranchCount;
 }

lib/workers/repository/process/write.spec.ts

@@ -12,7 +12,7 @@ import type {
 } from '../../../util/cache/repository/types';
 import { fingerprint } from '../../../util/fingerprint';
 import type { LongCommitSha } from '../../../util/git/types';
-import { isLimitReached } from '../../global/limits';
+import { counts } from '../../global/limits';
 import type { BranchConfig, BranchUpgradeConfig } from '../../types';
 import * as _branchWorker from '../update/branch';
 import * as _limits from './limits';
@@ -32,8 +32,9 @@ const repoCache = mocked(_repoCache);
 
 branchWorker.processBranch = jest.fn();
 
-limits.getPrsRemaining = jest.fn().mockResolvedValue(99);
-limits.getBranchesRemaining = jest.fn().mockResolvedValue(99);
+limits.getConcurrentPrsCount = jest.fn().mockResolvedValue(0);
+limits.getConcurrentBranchesCount = jest.fn().mockResolvedValue(0);
+limits.getPrHourlyCount = jest.fn().mockResolvedValue(0);
 
 let config: RenovateConfig;
 
@@ -104,22 +105,35 @@ describe('workers/repository/process/write', () => {
 
     it('increments branch counter', async () => {
       const branchName = 'branchName';
-      const branches: BranchConfig[] = [
-        { baseBranch: 'main', branchName, upgrades: [], manager: 'npm' },
-        { baseBranch: 'dev', branchName, upgrades: [], manager: 'npm' },
-      ];
+      const branches = partial<BranchConfig[]>([
+        {
+          baseBranch: 'main',
+          branchName,
+          upgrades: partial<BranchUpgradeConfig>([{ prConcurrentLimit: 10 }]),
+          manager: 'npm',
+        },
+        {
+          baseBranch: 'dev',
+          branchName,
+          upgrades: partial<BranchUpgradeConfig>([{ prConcurrentLimit: 10 }]),
+          manager: 'npm',
+        },
+      ]);
       repoCache.getCache.mockReturnValueOnce({});
       branchWorker.processBranch.mockResolvedValueOnce({
         branchExists: true,
         result: 'pr-created',
       });
-      scm.branchExists.mockResolvedValueOnce(false).mockResolvedValueOnce(true);
-      limits.getBranchesRemaining.mockResolvedValueOnce(1);
-      expect(isLimitReached('Branches')).toBeFalse();
+
+      limits.getConcurrentPrsCount.mockResolvedValue(0);
+      limits.getConcurrentBranchesCount.mockResolvedValue(0);
+      limits.getPrHourlyCount.mockResolvedValue(0);
+
+      scm.branchExists.mockResolvedValueOnce(false).mockResolvedValue(true);
       GlobalConfig.set({ dryRun: 'full' });
       config.baseBranches = ['main', 'dev'];
       await writeUpdates(config, branches);
-      expect(isLimitReached('Branches')).toBeTrue();
+      expect(counts.get('Branches')).toBe(1);
       expect(addMeta).toHaveBeenCalledWith({
         baseBranch: 'main',
         branch: branchName,

lib/workers/repository/process/write.ts

@@ -7,11 +7,15 @@ import { getCache } from '../../../util/cache/repository';
 import type { BranchCache } from '../../../util/cache/repository/types';
 import { fingerprint } from '../../../util/fingerprint';
 import { setBranchNewCommit } from '../../../util/git/set-branch-commit';
-import { incLimitedValue, setMaxLimit } from '../../global/limits';
+import { incCountValue, setCount } from '../../global/limits';
 import type { BranchConfig, UpgradeFingerprintConfig } from '../../types';
 import { processBranch } from '../update/branch';
 import { upgradeFingerprintFields } from './fingerprint-fields';
-import { getBranchesRemaining, getPrsRemaining } from './limits';
+import {
+  getConcurrentBranchesCount,
+  getConcurrentPrsCount,
+  getPrHourlyCount,
+} from './limits';
 
 export type WriteUpdateResult = 'done' | 'automerged';
 
@@ -127,15 +131,15 @@ export async function writeUpdates(
       .sort()
       .join(', ')}`,
   );
-  const prsRemaining = await getPrsRemaining(config, branches);
-  logger.debug(`Calculated maximum PRs remaining this run: ${prsRemaining}`);
-  setMaxLimit('PullRequests', prsRemaining);
 
-  const branchesRemaining = await getBranchesRemaining(config, branches);
-  logger.debug(
-    `Calculated maximum branches remaining this run: ${branchesRemaining}`,
-  );
-  setMaxLimit('Branches', branchesRemaining);
+  const concurrentPrsCount = await getConcurrentPrsCount(config, branches);
+  setCount('ConcurrentPRs', concurrentPrsCount);
+
+  const concurrentBranchesCount = await getConcurrentBranchesCount(branches);
+  setCount('Branches', concurrentBranchesCount);
+
+  const prsThisHourCount = await getPrHourlyCount(config);
+  setCount('HourlyPRs', prsThisHourCount);
 
   for (const branch of branches) {
     const { baseBranch, branchName } = branch;
@@ -182,7 +186,7 @@ export async function writeUpdates(
       return 'automerged';
     }
     if (!branchExisted && (await scm.branchExists(branch.branchName))) {
-      incLimitedValue('Branches');
+      incCountValue('Branches');
     }
   }
   removeMeta(['branch', 'baseBranch']);

lib/workers/repository/update/branch/index.ts

@@ -34,7 +34,7 @@ import {
 import { coerceNumber } from '../../../../util/number';
 import { toMs } from '../../../../util/pretty-time';
 import * as template from '../../../../util/template';
-import { isLimitReached } from '../../../global/limits';
+import { getCount, isLimitReached } from '../../../global/limits';
 import type { BranchConfig, BranchResult, PrBlockedBy } from '../../../types';
 import { embedChangelogs } from '../../changelog';
 import { ensurePr, getPlatformPrOptions } from '../pr';
@@ -212,9 +212,14 @@ export async function processBranch(
         };
       }
     }
+
+    logger.debug(
+      `Open PR Count: ${getCount('ConcurrentPRs')}, Existing Branch Count: ${getCount('Branches')}, Hourly PR Count: ${getCount('HourlyPRs')}`,
+    );
+
     if (
       !branchExists &&
-      isLimitReached('Branches') &&
+      isLimitReached('Branches', branchConfig) &&
       !dependencyDashboardCheck &&
       !config.isVulnerabilityAlert
     ) {

lib/workers/repository/update/pr/index.spec.ts

@@ -89,8 +89,9 @@ describe('workers/repository/update/pr/index', () => {
         const res = await ensurePr(config);
 
         expect(res).toEqual({ type: 'with-pr', pr });
-        expect(limits.incLimitedValue).toHaveBeenCalledOnce();
-        expect(limits.incLimitedValue).toHaveBeenCalledWith('PullRequests');
+        expect(limits.incCountValue).toHaveBeenCalledTimes(2);
+        expect(limits.incCountValue).toHaveBeenCalledWith('ConcurrentPRs');
+        expect(limits.incCountValue).toHaveBeenCalledWith('HourlyPRs');
         expect(logger.logger.info).toHaveBeenCalledWith(
           { pr: pr.number, prTitle },
           'PR created',

lib/workers/repository/update/pr/index.ts

@@ -27,7 +27,7 @@ import { stripEmojis } from '../../../../util/emoji';
 import { fingerprint } from '../../../../util/fingerprint';
 import { getBranchLastCommitTime } from '../../../../util/git';
 import { memoize } from '../../../../util/memoize';
-import { incLimitedValue, isLimitReached } from '../../../global/limits';
+import { incCountValue, isLimitReached } from '../../../global/limits';
 import type {
   BranchConfig,
   BranchUpgradeConfig,
@@ -482,7 +482,7 @@ export async function ensurePr(
       try {
         if (
           !dependencyDashboardCheck &&
-          isLimitReached('PullRequests') &&
+          isLimitReached('ConcurrentPRs', prConfig) &&
           !config.isVulnerabilityAlert
         ) {
           logger.debug('Skipping PR - limit reached');
@@ -499,7 +499,8 @@ export async function ensurePr(
           milestone: config.milestone,
         });
 
-        incLimitedValue('PullRequests');
+        incCountValue('ConcurrentPRs');
+        incCountValue('HourlyPRs');
         logger.info({ pr: pr?.number, prTitle }, 'PR created');
       } catch (err) {
         logger.debug({ err }, 'Pull request creation error');

package.json

@@ -152,14 +152,14 @@
     "@breejs/later": "4.2.0",
     "@cdktf/hcl2json": "0.20.11",
     "@opentelemetry/api": "1.9.0",
-    "@opentelemetry/context-async-hooks": "1.30.0",
-    "@opentelemetry/exporter-trace-otlp-http": "0.57.0",
-    "@opentelemetry/instrumentation": "0.57.0",
+    "@opentelemetry/context-async-hooks": "1.30.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.57.1",
+    "@opentelemetry/instrumentation": "0.57.1",
     "@opentelemetry/instrumentation-bunyan": "0.45.0",
-    "@opentelemetry/instrumentation-http": "0.57.0",
-    "@opentelemetry/resources": "1.30.0",
-    "@opentelemetry/sdk-trace-base": "1.30.0",
-    "@opentelemetry/sdk-trace-node": "1.30.0",
+    "@opentelemetry/instrumentation-http": "0.57.1",
+    "@opentelemetry/resources": "1.30.1",
+    "@opentelemetry/sdk-trace-base": "1.30.1",
+    "@opentelemetry/sdk-trace-node": "1.30.1",
     "@opentelemetry/semantic-conventions": "1.28.0",
     "@qnighy/marshal": "0.1.3",
     "@renovatebot/detect-tools": "1.1.0",
@@ -207,7 +207,7 @@
     "got": "11.8.6",
     "graph-data-structure": "4.3.0",
     "handlebars": "4.7.8",
-    "ignore": "7.0.2",
+    "ignore": "7.0.3",
     "ini": "5.0.0",
     "json-dup-key-validator": "1.0.3",
     "json-stringify-pretty-compact": "3.0.0",

pnpm-lock.yaml

@@ -39,29 +39,29 @@ importers:
         specifier: 1.9.0
         version: 1.9.0
       '@opentelemetry/context-async-hooks':
-        specifier: 1.30.0
-        version: 1.30.0(@opentelemetry/api@1.9.0)
+        specifier: 1.30.1
+        version: 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/exporter-trace-otlp-http':
-        specifier: 0.57.0
-        version: 0.57.0(@opentelemetry/api@1.9.0)
+        specifier: 0.57.1
+        version: 0.57.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/instrumentation':
-        specifier: 0.57.0
-        version: 0.57.0(@opentelemetry/api@1.9.0)
+        specifier: 0.57.1
+        version: 0.57.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/instrumentation-bunyan':
         specifier: 0.45.0
         version: 0.45.0(@opentelemetry/api@1.9.0)
       '@opentelemetry/instrumentation-http':
-        specifier: 0.57.0
-        version: 0.57.0(@opentelemetry/api@1.9.0)
+        specifier: 0.57.1
+        version: 0.57.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/resources':
-        specifier: 1.30.0
-        version: 1.30.0(@opentelemetry/api@1.9.0)
+        specifier: 1.30.1
+        version: 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/sdk-trace-base':
-        specifier: 1.30.0
-        version: 1.30.0(@opentelemetry/api@1.9.0)
+        specifier: 1.30.1
+        version: 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/sdk-trace-node':
-        specifier: 1.30.0
-        version: 1.30.0(@opentelemetry/api@1.9.0)
+        specifier: 1.30.1
+        version: 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions':
         specifier: 1.28.0
         version: 1.28.0
@@ -204,8 +204,8 @@ importers:
         specifier: 4.7.8
         version: 4.7.8
       ignore:
-        specifier: 7.0.2
-        version: 7.0.2
+        specifier: 7.0.3
+        version: 7.0.3
       ini:
         specifier: 5.0.0
         version: 5.0.0
@@ -1325,10 +1325,6 @@ packages:
       typescript:
         optional: true
 
-  '@opentelemetry/api-logs@0.57.0':
-    resolution: {integrity: sha512-l1aJ30CXeauVYaI+btiynHpw341LthkMTv3omi1VJDX14werY2Wmv9n1yudMsq9HuY0m8PvXEVX4d8zxEb+WRg==}
-    engines: {node: '>=14'}
-
   '@opentelemetry/api-logs@0.57.1':
     resolution: {integrity: sha512-I4PHczeujhQAQv6ZBzqHYEUiggZL4IdSMixtVD3EYqbdrjujE7kRfI5QohjlPoJm8BvenoW5YaTMWRrbpot6tg==}
     engines: {node: '>=14'}
@@ -1337,20 +1333,20 @@ packages:
     resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==}
     engines: {node: '>=8.0.0'}
 
-  '@opentelemetry/context-async-hooks@1.30.0':
-    resolution: {integrity: sha512-roCetrG/cz0r/gugQm/jFo75UxblVvHaNSRoR0kSSRSzXFAiIBqFCZuH458BHBNRtRe+0yJdIJ21L9t94bw7+g==}
+  '@opentelemetry/context-async-hooks@1.30.1':
+    resolution: {integrity: sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/core@1.30.0':
-    resolution: {integrity: sha512-Q/3u/K73KUjTCnFUP97ZY+pBjQ1kPEgjOfXj/bJl8zW7GbXdkw6cwuyZk6ZTXkVgCBsYRYUzx4fvYK1jxdb9MA==}
+  '@opentelemetry/core@1.30.1':
+    resolution: {integrity: sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/exporter-trace-otlp-http@0.57.0':
-    resolution: {integrity: sha512-BJl35PSkwoMlGEOrzjCG1ih6zqZoAZJIR4xyqSKC2BqPtwuRjID0vWBaEdP9xrxxJTEIEQw+gEY/0pUgicX0ew==}
+  '@opentelemetry/exporter-trace-otlp-http@0.57.1':
+    resolution: {integrity: sha512-43dLEjlf6JGxpVt9RaRlJAvjHG1wGsbAuNd67RIDy/95zfKk2aNovtiGUgFdS/kcvgvS90upIUbgn0xUd9JjMg==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
@@ -1361,68 +1357,68 @@ packages:
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
-  '@opentelemetry/instrumentation-http@0.57.0':
-    resolution: {integrity: sha512-GJD6e/YSSZUI/xZokK9L+ghMAyFrtGV+8HHXCnV8tDYCo66biLpmC9BUTg6fBnv26QsosYvFTYbdo6Sfn6TxCw==}
+  '@opentelemetry/instrumentation-http@0.57.1':
+    resolution: {integrity: sha512-ThLmzAQDs7b/tdKI3BV2+yawuF09jF111OFsovqT1Qj3D8vjwKBwhi/rDE5xethwn4tSXtZcJ9hBsVAlWFQZ7g==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
-  '@opentelemetry/instrumentation@0.57.0':
-    resolution: {integrity: sha512-qIKp+tSCLqofneUWRc5XHtr9jHIq0N0BJfaJamM9gjEFO8sthV4SDXDGNOSAx16PxkbrQJ5/AxMPAGCXl8W/Hg==}
+  '@opentelemetry/instrumentation@0.57.1':
+    resolution: {integrity: sha512-SgHEKXoVxOjc20ZYusPG3Fh+RLIZTSa4x8QtD3NfgAUDyqdFFS9W1F2ZVbZkqDCdyMcQG02Ok4duUGLHJXHgbA==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
-  '@opentelemetry/otlp-exporter-base@0.57.0':
-    resolution: {integrity: sha512-QQl4Ngm3D6H8SDO0EM642ncTxjRsf/HDq7+IWIA0eaEK/NTsJeQ3iYJiZj3F4jkALnvyeM1kkwd+DHtqxTBx9Q==}
+  '@opentelemetry/otlp-exporter-base@0.57.1':
+    resolution: {integrity: sha512-GNBJAEYfeiYJQ3O2dvXgiNZ/qjWrBxSb1L1s7iV/jKBRGMN3Nv+miTk2SLeEobF5E5ZK4rVcHKlBZ71bPVIv/g==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
-  '@opentelemetry/otlp-transformer@0.57.0':
-    resolution: {integrity: sha512-yHX7sdwkdAmSa6Jbi3caSLDWy0PCHS1pKQeKz8AIWSyQqL7IojHKgdk9A+7eRd98Z1n9YTdwWSWLnObvIqhEhQ==}
+  '@opentelemetry/otlp-transformer@0.57.1':
+    resolution: {integrity: sha512-EX67y+ukNNfFrOLyjYGw8AMy0JPIlEX1dW60SGUNZWW2hSQyyolX7EqFuHP5LtXLjJHNfzx5SMBVQ3owaQCNDw==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
-  '@opentelemetry/propagator-b3@1.30.0':
-    resolution: {integrity: sha512-lcobQQmd+hLdtxJJKu/i51lNXmF1PJJ7Y9B97ciHRVQuMI260vSZG7Uf4Zg0fqR8PB+fT/7rnlDwS0M7QldZQQ==}
+  '@opentelemetry/propagator-b3@1.30.1':
+    resolution: {integrity: sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/propagator-jaeger@1.30.0':
-    resolution: {integrity: sha512-0hdP495V6HPRkVpowt54+Swn5NdesMIRof+rlp0mbnuIUOM986uF+eNxnPo9q5MmJegVBRTxgMHXXwvnXRnKRg==}
+  '@opentelemetry/propagator-jaeger@1.30.1':
+    resolution: {integrity: sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/resources@1.30.0':
-    resolution: {integrity: sha512-5mGMjL0Uld/99t7/pcd7CuVtJbkARckLVuiOX84nO8RtLtIz0/J6EOHM2TGvPZ6F4K+XjUq13gMx14w80SVCQg==}
+  '@opentelemetry/resources@1.30.1':
+    resolution: {integrity: sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/sdk-logs@0.57.0':
-    resolution: {integrity: sha512-6Kbxdu/QE9LWH7+WSLmYo3DjAq+c55TiCLXiXu6b/2m2muy5SyOG2m0MrGqetyRpfYSSbIqHmJoqNVTN3+2a9g==}
+  '@opentelemetry/sdk-logs@0.57.1':
+    resolution: {integrity: sha512-jGdObb/BGWu6Peo3cL3skx/Rl1Ak/wDDO3vpPrrThGbqE7isvkCsX6uE+OAt8Ayjm9YC8UGkohWbLR09JmM0FA==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.4.0 <1.10.0'
 
-  '@opentelemetry/sdk-metrics@1.30.0':
-    resolution: {integrity: sha512-5kcj6APyRMvv6dEIP5plz2qfJAD4OMipBRT11u/pa1a68rHKI2Ln+iXVkAGKgx8o7CXbD7FdPypTUY88ZQgP4Q==}
+  '@opentelemetry/sdk-metrics@1.30.1':
+    resolution: {integrity: sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.3.0 <1.10.0'
 
-  '@opentelemetry/sdk-trace-base@1.30.0':
-    resolution: {integrity: sha512-RKQDaDIkV7PwizmHw+rE/FgfB2a6MBx+AEVVlAHXRG1YYxLiBpPX2KhmoB99R5vA4b72iJrjle68NDWnbrE9Dg==}
+  '@opentelemetry/sdk-trace-base@1.30.1':
+    resolution: {integrity: sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
 
-  '@opentelemetry/sdk-trace-node@1.30.0':
-    resolution: {integrity: sha512-MeXkXEdBs9xq1JSGTr/3P1lHBSUBaVmo1+UpoQhUpviPMzDXy0MNsdTC7KKI6/YcG74lTX6eqeNjlC1jV4Rstw==}
+  '@opentelemetry/sdk-trace-node@1.30.1':
+    resolution: {integrity: sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==}
     engines: {node: '>=14'}
     peerDependencies:
       '@opentelemetry/api': '>=1.0.0 <1.10.0'
@@ -3801,8 +3797,8 @@ packages:
     resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
     engines: {node: '>= 4'}
 
-  ignore@7.0.2:
-    resolution: {integrity: sha512-Wx5VKTZatJNNa26J1dMfJF1bZu4Lw31EHwhFRcSjTvro8Mqsrd3rJanyW48W43Eyd+gpaiDNkveYd62DvXaZeQ==}
+  ignore@7.0.3:
+    resolution: {integrity: sha512-bAH5jbK/F3T3Jls4I0SO1hmPR0dKU0a7+SY6n1yzRtG54FLO8d6w/nxLFX2Nb7dBu6cCWXPaAME6cYqFUMmuCA==}
     engines: {node: '>= 4'}
 
   immediate@3.0.6:
@@ -7872,58 +7868,54 @@ snapshots:
     optionalDependencies:
       typescript: 5.7.3
 
-  '@opentelemetry/api-logs@0.57.0':
-    dependencies:
-      '@opentelemetry/api': 1.9.0
-
   '@opentelemetry/api-logs@0.57.1':
     dependencies:
       '@opentelemetry/api': 1.9.0
 
   '@opentelemetry/api@1.9.0': {}
 
-  '@opentelemetry/context-async-hooks@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/context-async-hooks@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
 
-  '@opentelemetry/core@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/core@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
       '@opentelemetry/semantic-conventions': 1.28.0
 
-  '@opentelemetry/exporter-trace-otlp-http@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/exporter-trace-otlp-http@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/otlp-exporter-base': 0.57.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/otlp-transformer': 0.57.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/resources': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/sdk-trace-base': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/otlp-exporter-base': 0.57.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/otlp-transformer': 0.57.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0)
 
   '@opentelemetry/instrumentation-bunyan@0.45.0(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
       '@opentelemetry/api-logs': 0.57.1
-      '@opentelemetry/instrumentation': 0.57.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/instrumentation': 0.57.1(@opentelemetry/api@1.9.0)
       '@types/bunyan': 1.8.9
     transitivePeerDependencies:
       - supports-color
 
-  '@opentelemetry/instrumentation-http@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/instrumentation-http@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/instrumentation': 0.57.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/instrumentation': 0.57.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions': 1.28.0
       forwarded-parse: 2.1.2
       semver: 7.6.3
     transitivePeerDependencies:
       - supports-color
 
-  '@opentelemetry/instrumentation@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/instrumentation@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/api-logs': 0.57.0
+      '@opentelemetry/api-logs': 0.57.1
       '@types/shimmer': 1.2.0
       import-in-the-middle: 1.12.0
       require-in-the-middle: 7.4.0
@@ -7932,67 +7924,67 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@opentelemetry/otlp-exporter-base@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/otlp-exporter-base@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/otlp-transformer': 0.57.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/otlp-transformer': 0.57.1(@opentelemetry/api@1.9.0)
 
-  '@opentelemetry/otlp-transformer@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/otlp-transformer@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/api-logs': 0.57.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/resources': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/sdk-logs': 0.57.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/sdk-metrics': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/sdk-trace-base': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/api-logs': 0.57.1
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-logs': 0.57.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-metrics': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0)
       protobufjs: 7.4.0
 
-  '@opentelemetry/propagator-b3@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/propagator-b3@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
 
-  '@opentelemetry/propagator-jaeger@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/propagator-jaeger@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
 
-  '@opentelemetry/resources@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/resources@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions': 1.28.0
 
-  '@opentelemetry/sdk-logs@0.57.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/sdk-logs@0.57.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/api-logs': 0.57.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/resources': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/api-logs': 0.57.1
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0)
 
-  '@opentelemetry/sdk-metrics@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/sdk-metrics@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/resources': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0)
 
-  '@opentelemetry/sdk-trace-base@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/sdk-trace-base@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/resources': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/resources': 1.30.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions': 1.28.0
 
-  '@opentelemetry/sdk-trace-node@1.30.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/sdk-trace-node@1.30.1(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/context-async-hooks': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/core': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/propagator-b3': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/propagator-jaeger': 1.30.0(@opentelemetry/api@1.9.0)
-      '@opentelemetry/sdk-trace-base': 1.30.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/context-async-hooks': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/core': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/propagator-b3': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/propagator-jaeger': 1.30.1(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/api@1.9.0)
       semver: 7.6.3
 
   '@opentelemetry/semantic-conventions@1.28.0': {}
@@ -10810,7 +10802,7 @@ snapshots:
 
   ignore@5.3.2: {}
 
-  ignore@7.0.2: {}
+  ignore@7.0.3: {}
 
   immediate@3.0.6: {}