Always send large traces as stats

.changeset/yellow-actors-do.md

@@ -0,0 +1,5 @@
+---
+'@apollo/server': patch
+---
+
+Send large traces as stats

packages/server/src/__tests__/plugin/usageReporting/stats.test.ts

@@ -1,8 +1,13 @@
-import { Trace } from '@apollo/usage-reporting-protobuf';
+import {
+ Trace,
+ ReportHeader,
+ ReferencedFieldsForType,
+} from '@apollo/usage-reporting-protobuf';
 import { dateToProtoTimestamp } from '../../../plugin/traceTreeBuilder';
 import {
  OurContextualizedStats,
  SizeEstimator,
+ OurReport,
 } from '../../../plugin/usageReporting/stats';
 import { DurationHistogram } from '../../../plugin/usageReporting/durationHistogram';
 import { describe, it, expect } from '@jest/globals';
@@ -473,3 +478,81 @@ describe('Check type stats', () => {
  expect(contextualizedStats).toMatchSnapshot();
  });
 });
+
+describe('Add trace to report', () => {
+ const defaultHeader = new ReportHeader({
+ hostname: 'hostname',
+ agentVersion: `@apollo/server`,
+ runtimeVersion: `node latest`,
+ uname: 'uname',
+ executableSchemaId: 'schema',
+ graphRef: 'graph',
+ });
+ const referencedFieldsByType = Object.create(null);
+ referencedFieldsByType['type'] = new ReferencedFieldsForType({
+ fieldNames: ['field1', 'field2'],
+ isInterface: false,
+ });
+
+ it('add as stats if asTrace is false', () => {
+ const report = new OurReport(defaultHeader);
+ report.addTrace({
+ statsReportKey: 'key',
+ trace: baseTrace,
+ asTrace: false,
+ referencedFieldsByType,
+ });
+
+ expect(report.tracesPerQuery['key']?.trace?.length).toBe(0);
+ expect(
+ Object.keys(report.tracesPerQuery['key']?.statsWithContext?.map).length,
+ ).toBe(1);
+ });
+
+ it('add as stats if asTrace is true but trace is too large', () => {
+ const report = new OurReport(defaultHeader);
+ report.addTrace({
+ statsReportKey: 'key',
+ trace: baseTrace,
+ asTrace: true,
+ referencedFieldsByType,
+ maxTraceBytes: 10,
+ });
+
+ expect(report.tracesPerQuery['key']?.trace?.length).toBe(0);
+ expect(
+ Object.keys(report.tracesPerQuery['key']?.statsWithContext?.map).length,
+ ).toBe(1);
+ });
+
+ it('add as trace if asTrace is true and trace is not too large', () => {
+ const report = new OurReport(defaultHeader);
+ report.addTrace({
+ statsReportKey: 'key',
+ trace: baseTrace,
+ asTrace: true,
+ referencedFieldsByType,
+ maxTraceBytes: 500 * 1024,
+ });
+
+ expect(report.tracesPerQuery['key']?.trace?.length).toBe(1);
+ expect(
+ Object.keys(report.tracesPerQuery['key']?.statsWithContext?.map).length,
+ ).toBe(0);
+ });
+
+ it('add as trace if asTrace is true and trace is not too large and max trace size is left as default', () => {
+ const report = new OurReport(defaultHeader);
+ report.addTrace({
+ statsReportKey: 'key',
+ trace: baseTrace,
+ asTrace: true,
+ referencedFieldsByType,
+ });
+
+ expect(report.tracesPerQuery['key']?.trace?.length).toBe(1);
+ expect(
+ Object.keys(report.tracesPerQuery['key']?.statsWithContext?.map).length,
+ ).toBe(0);
+ });
+});

packages/server/src/plugin/usageReporting/defaultSendOperationsAsTrace.ts

@@ -9,7 +9,10 @@ export function defaultSendOperationsAsTrace() {
  // operation, what minute the operation ended at, etc) to `true` if we've seen
  // it recently. We actually split this into one cache per minute so we can
  // throw away a full minute's worth of cache at once; we keep only the last
- // three minutes
+ // three minutes.
+ // Note that if a trace is over a certain size, we will always send it as
+ // stats. We check this within the addTrace function of the OurReport class so
+ // that we don't have to encode these large traces twice.
  const cache = new LRUCache<string, true>({
  // 3MiB limit, very much approximately since we can't be sure how V8 might
  // be storing these strings internally. Though this should be enough to

packages/server/src/plugin/usageReporting/plugin.ts

@@ -680,7 +680,7 @@ export function ApolloServerPluginUsageReporting<TContext extends BaseContext>(
  trace,
  // We include the operation as a trace (rather than aggregated
  // into stats) only if the user didn't set `sendTraces: false`
- // *and8 we believe it's possible that our organization's plan
+ // *and* we believe it's possible that our organization's plan
  // allows for viewing traces *and* we actually captured this as
  // a full trace *and* sendOperationAsTrace says so.
  //

packages/server/src/plugin/usageReporting/stats.ts

@@ -61,20 +61,30 @@ export class OurReport implements Required<IReport> {
  trace,
  asTrace,
  referencedFieldsByType,
+ // The max size a trace can be before it is sent as stats. Note that the
+ // Apollo reporting ingress server will never store any traces over 10mb
+ // anyway. They will instead be converted to stats as we would do here.
+ maxTraceBytes = 10 * 1024 * 1024,
  }: {
  statsReportKey: string;
  trace: Trace;
  asTrace: boolean;
  referencedFieldsByType: ReferencedFieldsByType;
+ maxTraceBytes?: number;
  }) {
  const tracesAndStats = this.getTracesAndStats({
  statsReportKey,
  referencedFieldsByType,
  });
  if (asTrace) {
  const encodedTrace = Trace.encode(trace).finish();
- tracesAndStats.trace.push(encodedTrace);
- this.sizeEstimator.bytes += 2 + encodedTrace.length;
+
+ if (!isNaN(maxTraceBytes) && encodedTrace.length > maxTraceBytes) {
+ tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator);
+ } else {
+ tracesAndStats.trace.push(encodedTrace);
+ this.sizeEstimator.bytes += 2 + encodedTrace.length;
+ }
  } else {
  tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator);
  }