feat: Ability to limit number of recorded function calls

[zermelo-wisen]

Fixes #162.

Summary

• Added the ability to limit the number of recorded function calls, both total and per function. This approach ensures no orphaned calls are recorded, as the check is made at the start of the function call recording.

• The limits can be configured via environment variables (APPMAP_MAX_RECORDED_CALLS & APPMAP_MAX_RECORDED_CALLS_PER_FUNCTION) and configuration file, with default values of 10,000,000 total calls and 100,000 calls per function.

• Introduced a new test case that generates an AppMap with enforced total and per-function call limits.

Detailed Description

This PR introduces functionality and configuration updates to limit the number of function calls and total calls that can be recorded by the AppMap recorder.

File: src/Recording.ts

• Added call count tracking:
  • Introduced callCountPerFunction and totalCallCount to track the number of calls per function and the total number of calls, respectively.

private callCountPerFunction = new Map<FunctionInfo, number>();
private totalCallCount = 0;

• Implemented function call limit checks:
  • The method willExceedFunctionCallLimits was added to determine if the next function call would exceed predefined limits specified in the configuration.

public willExceedFunctionCallLimits(funInfo: FunctionInfo) {
  return (
    (config().maxRecordedCalls > 0 && this.totalCallCount >= config().maxRecordedCalls) ||
    (config().maxRecordedCallsPerFunction &&
      (this.callCountPerFunction.get(funInfo) ?? 0) >= config().maxRecordedCallsPerFunction)
  );
}

• Modified functionCall method:
  • Updated to increment the call counters every time a function is recorded.

const count = this.callCountPerFunction.get(funInfo) ?? 0;
this.callCountPerFunction.set(funInfo, count + 1);
this.totalCallCount++;

File: src/config.ts

• Added new default configuration values and environment variable names:

const maxRecordedCallsDefault = 10_000_000;
const kMaxRecordedCallsEnvar = "APPMAP_MAX_RECORDED_CALLS";

const maxRecordedCallsPerFunctionDefault = 100_000;
const kMaxRecordedCallsPerFunctionEnvar = "APPMAP_MAX_RECORDED_CALLS_PER_FUNCTION";

• Updated Config class:
  • Introduced new properties to store the maximum recorded calls and maximum recorded calls per function.

public maxRecordedCalls: number;
public maxRecordedCallsPerFunction: number;

• Initialized these properties in the Config constructor.

this.maxRecordedCalls =
  getNonNegativeIntegerEnvVarValue(kMaxRecordedCallsEnvar) ??
  config?.max_recorded_calls ??
  maxRecordedCallsDefault;

this.maxRecordedCallsPerFunction =
  getNonNegativeIntegerEnvVarValue(kMaxRecordedCallsPerFunctionEnvar) ??
  config?.max_recorded_calls_per_function ??
  maxRecordedCallsPerFunctionDefault;

• Updated readConfigFile function:
  • Extended the parsing to include new configuration options max_recorded_calls and max_recorded_calls_per_function.

if ("max_recorded_calls" in config) {
  const value = parseInt(String(config.max_recorded_calls));
  result.max_recorded_calls = value >= 0 ? value : undefined;
}
if ("max_recorded_calls_per_function" in config) {
  const value = parseInt(String(config.max_recorded_calls_per_function));
  result.max_recorded_calls_per_function = value >= 0 ? value : undefined;
}

File: src/recorder.ts

• Filtered function recordings:
  • Changed the record function to skip recordings that would exceed the specified function call limits.

const recordings = getActiveRecordings().filter((r) => !r.willExceedFunctionCallLimits(funInfo));

Testing

• Added a new integration test for function call limits:
  • Created mapping a script using function call limits to validate the behavior of the new function call limits feature.

integrationTest.only("mapping a script using function call limits", () => {
  const options = {
    env: {
      ...process.env,
      APPMAP_MAX_RECORDED_CALLS: "5",
      APPMAP_MAX_RECORDED_CALLS_PER_FUNCTION: "2",
    },
  };
  expect(runAppmapNodeWithOptions(options, "callLimits.js").status).toBe(0);
  expect(readAppmap()).toMatchSnapshot();
});

• Created callLimits.js for testing:
  • A simple script that calls functions a, b, and c multiple times to test the limits.

function a() {
  console.log("a");
}

function b() {
  console.log("b");
}

function c() {
  console.log("c");
}

a();
a();
a();

b();
b();
b();

c();
c();
c();