@graphql-yoga/plugin-apollo-usage-report 0.13.0 → 0.13.1-alpha-20260116132831-dc9fc0ad2f1ad6ee99bc438c173cf8496ae505a7

package/dist/reporter.d.cts

@@ -0,0 +1,23 @@
+import { OurReport } from "./stats.cjs";
+import { ApolloUsageReportOptions } from "./index.cjs";
+import { YogaLogger, YogaServer } from "graphql-yoga";
+import { google } from "@apollo/usage-reporting-protobuf";
+
+//#region src/reporter.d.ts
+declare class Reporter {
+  private yoga;
+  private logger;
+  private reportHeaders;
+  private options;
+  private reportsBySchema;
+  private nextSendAfterDelay?;
+  private sending;
+  constructor(options: ApolloUsageReportOptions, yoga: YogaServer<Record<string, unknown>, Record<string, unknown>>, logger: YogaLogger);
+  addTrace(schemaId: string, options: Parameters<OurReport['addTrace']>[0]): Promise<void> | undefined;
+  flush(): Promise<PromiseSettledResult<unknown>[]>;
+  sendReport(schemaId: string): Promise<void>;
+  private _sendReport;
+  private getReport;
+}
+//#endregion
+export { Reporter };

package/dist/reporter.d.mts

@@ -0,0 +1,23 @@
+import { OurReport } from "./stats.mjs";
+import { ApolloUsageReportOptions } from "./index.mjs";
+import { YogaLogger, YogaServer } from "graphql-yoga";
+import { google } from "@apollo/usage-reporting-protobuf";
+
+//#region src/reporter.d.ts
+declare class Reporter {
+  private yoga;
+  private logger;
+  private reportHeaders;
+  private options;
+  private reportsBySchema;
+  private nextSendAfterDelay?;
+  private sending;
+  constructor(options: ApolloUsageReportOptions, yoga: YogaServer<Record<string, unknown>, Record<string, unknown>>, logger: YogaLogger);
+  addTrace(schemaId: string, options: Parameters<OurReport['addTrace']>[0]): Promise<void> | undefined;
+  flush(): Promise<PromiseSettledResult<unknown>[]>;
+  sendReport(schemaId: string): Promise<void>;
+  private _sendReport;
+  private getReport;
+}
+//#endregion
+export { Reporter };

package/dist/reporter.mjs

@@ -0,0 +1,117 @@
+import { OurReport } from "./stats.mjs";
+import { Report, ReportHeader, google } from "@apollo/usage-reporting-protobuf";
+
+//#region src/reporter.ts
+const DEFAULT_REPORTING_ENDPOINT = "https://usage-reporting.api.apollographql.com/api/ingress/traces";
+var Reporter = class {
+	reportHeaders;
+	options;
+	reportsBySchema = {};
+	nextSendAfterDelay;
+	sending = [];
+	constructor(options, yoga, logger) {
+		this.yoga = yoga;
+		this.logger = logger;
+		this.options = {
+			...options,
+			maxBatchDelay: options.maxBatchDelay ?? 2e4,
+			maxBatchUncompressedSize: options.maxBatchUncompressedSize ?? 4 * 1024 * 1024,
+			maxTraceSize: options.maxTraceSize ?? 10 * 1024 * 1024,
+			exportTimeout: options.exportTimeout ?? 3e4,
+			onError: options.onError ?? ((err) => this.logger.error("Failed to send report", err))
+		};
+		this.reportHeaders = {
+			graphRef: getGraphRef(options),
+			hostname: options.hostname ?? getEnvVar("HOSTNAME") ?? "",
+			uname: options.uname ?? "",
+			runtimeVersion: options.runtimeVersion ?? "",
+			agentVersion: options.agentVersion || `graphql-yoga@${yoga.version}`
+		};
+	}
+	addTrace(schemaId, options) {
+		const report = this.getReport(schemaId);
+		report.addTrace(options);
+		if (this.options.alwaysSend || report.sizeEstimator.bytes >= this.options.maxBatchUncompressedSize) return this._sendReport(schemaId);
+		this.nextSendAfterDelay ||= setTimeout(() => this.flush(), this.options.maxBatchDelay);
+	}
+	async flush() {
+		return Promise.allSettled([...this.sending, ...Object.keys(this.reportsBySchema).map((schemaId) => this._sendReport(schemaId))]);
+	}
+	async sendReport(schemaId) {
+		const sending = this._sendReport(schemaId);
+		this.sending.push(sending);
+		sending.finally(() => this.sending = this.sending?.filter((p) => p !== sending));
+		return sending;
+	}
+	async _sendReport(schemaId) {
+		const { fetchAPI: { fetch, CompressionStream, ReadableStream } } = this.yoga;
+		const report = this.reportsBySchema[schemaId];
+		if (!report) throw new Error(`No report to send for schema ${schemaId}`);
+		if (this.nextSendAfterDelay != null) {
+			clearTimeout(this.nextSendAfterDelay);
+			this.nextSendAfterDelay = void 0;
+		}
+		delete this.reportsBySchema[schemaId];
+		report.endTime = dateToProtoTimestamp(/* @__PURE__ */ new Date());
+		report.ensureCountsAreIntegers();
+		const validationError = Report.verify(report);
+		if (validationError) throw new TypeError(`Invalid report: ${validationError}`);
+		const { apiKey = getEnvVar("APOLLO_KEY"), endpoint = DEFAULT_REPORTING_ENDPOINT } = this.options;
+		const encodedReport = Report.encode(report).finish();
+		let lastError;
+		for (let tries = 0; tries < 5; tries++) try {
+			this.logger.debug(`Sending report (try ${tries}/5)`);
+			const response = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					"content-type": "application/protobuf",
+					"content-encoding": "gzip",
+					"x-api-key": apiKey,
+					accept: "application/json"
+				},
+				body: new ReadableStream({ start(controller) {
+					controller.enqueue(encodedReport);
+					controller.close();
+				} }).pipeThrough(new CompressionStream("gzip")),
+				signal: AbortSignal.timeout(this.options.exportTimeout)
+			});
+			const result = await response.text();
+			if (response.ok) {
+				this.logger.debug("Report sent:", result);
+				return;
+			}
+			throw result;
+		} catch (err) {
+			lastError = err;
+			this.logger.error("Failed to send report:", err);
+		}
+		this.options.onError(new Error("Failed to send traces after 5 tries", { cause: lastError }));
+	}
+	getReport(schemaId) {
+		const report = this.reportsBySchema[schemaId];
+		if (report) return report;
+		return this.reportsBySchema[schemaId] = new OurReport(new ReportHeader({
+			...this.reportHeaders,
+			executableSchemaId: schemaId
+		}));
+	}
+};
+function getGraphRef(options) {
+	const graphRef = options.graphRef || getEnvVar("APOLLO_GRAPH_REF");
+	if (!graphRef) throw new Error("Missing GraphRef. Either provide `graphRef` option or `APOLLO_GRAPH_REF` environment variable");
+	return graphRef;
+}
+function getEnvVar(name, defaultValue) {
+	return globalThis.process?.env?.[name] || defaultValue || void 0;
+}
+function dateToProtoTimestamp(date) {
+	const totalMillis = date.getTime();
+	const millis = totalMillis % 1e3;
+	return new google.protobuf.Timestamp({
+		seconds: (totalMillis - millis) / 1e3,
+		nanos: millis * 1e6
+	});
+}
+
+//#endregion
+export { Reporter, getEnvVar };

package/dist/stats.cjs

@@ -0,0 +1,344 @@
+let _apollo_usage_reporting_protobuf = require("@apollo/usage-reporting-protobuf");
+
+//#region src/stats.ts
+var SizeEstimator = class {
+	bytes = 0;
+};
+var OurReport = class {
+	tracesPreAggregated = false;
+	constructor(header) {
+		this.header = header;
+	}
+	tracesPerQuery = Object.create(null);
+	endTime = null;
+	operationCount = 0;
+	sizeEstimator = new SizeEstimator();
+	ensureCountsAreIntegers() {
+		for (const tracesAndStats of Object.values(this.tracesPerQuery)) tracesAndStats.ensureCountsAreIntegers();
+	}
+	addTrace({ statsReportKey, trace, asTrace, referencedFieldsByType, maxTraceBytes = 10 * 1024 * 1024, nonFtv1ErrorPaths }) {
+		const tracesAndStats = this.getTracesAndStats({
+			statsReportKey,
+			referencedFieldsByType
+		});
+		if (asTrace) {
+			const encodedTrace = _apollo_usage_reporting_protobuf.Trace.encode(trace).finish();
+			if (!isNaN(maxTraceBytes) && encodedTrace.length > maxTraceBytes) tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator, nonFtv1ErrorPaths);
+			else {
+				tracesAndStats.trace.push(encodedTrace);
+				this.sizeEstimator.bytes += 2 + encodedTrace.length;
+			}
+		} else tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator, nonFtv1ErrorPaths);
+	}
+	getTracesAndStats({ statsReportKey, referencedFieldsByType }) {
+		const existing = this.tracesPerQuery[statsReportKey];
+		if (existing) return existing;
+		this.sizeEstimator.bytes += estimatedBytesForString(statsReportKey);
+		for (const [typeName, referencedFieldsForType] of Object.entries(referencedFieldsByType)) {
+			this.sizeEstimator.bytes += 4;
+			if (referencedFieldsForType.isInterface) this.sizeEstimator.bytes += 2;
+			this.sizeEstimator.bytes += estimatedBytesForString(typeName);
+			for (const fieldName of referencedFieldsForType.fieldNames) this.sizeEstimator.bytes += estimatedBytesForString(fieldName);
+		}
+		return this.tracesPerQuery[statsReportKey] = new OurTracesAndStats(referencedFieldsByType);
+	}
+};
+var OurTracesAndStats = class {
+	constructor(referencedFieldsByType) {
+		this.referencedFieldsByType = referencedFieldsByType;
+	}
+	trace = [];
+	statsWithContext = new StatsByContext();
+	internalTracesContributingToStats = [];
+	ensureCountsAreIntegers() {
+		this.statsWithContext.ensureCountsAreIntegers();
+	}
+};
+var StatsByContext = class {
+	map = Object.create(null);
+	/**
+	* This function is used by the protobuf generator to convert this map into
+	* an array of contextualized stats to serialize
+	*/
+	toArray() {
+		return Object.values(this.map);
+	}
+	ensureCountsAreIntegers() {
+		for (const contextualizedStats of Object.values(this.map)) contextualizedStats.ensureCountsAreIntegers();
+	}
+	addTrace(trace, sizeEstimator, nonFtv1ErrorPaths) {
+		this.getContextualizedStats(trace, sizeEstimator).addTrace(trace, sizeEstimator, nonFtv1ErrorPaths);
+	}
+	getContextualizedStats(trace, sizeEstimator) {
+		const statsContext = {
+			clientName: trace.clientName,
+			clientVersion: trace.clientVersion
+		};
+		const statsContextKey = JSON.stringify(statsContext);
+		const existing = this.map[statsContextKey];
+		if (existing) return existing;
+		sizeEstimator.bytes += 20 + estimatedBytesForString(trace.clientName) + estimatedBytesForString(trace.clientVersion);
+		const contextualizedStats = new OurContextualizedStats(statsContext);
+		this.map[statsContextKey] = contextualizedStats;
+		return contextualizedStats;
+	}
+};
+var OurContextualizedStats = class {
+	queryLatencyStats = new OurQueryLatencyStats();
+	perTypeStat = Object.create(null);
+	constructor(context) {
+		this.context = context;
+	}
+	ensureCountsAreIntegers() {
+		for (const typeStat of Object.values(this.perTypeStat)) typeStat.ensureCountsAreIntegers();
+	}
+	addTrace(trace, sizeEstimator, nonFtv1ErrorPaths = []) {
+		const { fieldExecutionWeight } = trace;
+		if (!fieldExecutionWeight) this.queryLatencyStats.requestsWithoutFieldInstrumentation++;
+		this.queryLatencyStats.requestCount++;
+		if (trace.fullQueryCacheHit) {
+			this.queryLatencyStats.cacheLatencyCount.incrementDuration(trace.durationNs);
+			this.queryLatencyStats.cacheHits++;
+		} else this.queryLatencyStats.latencyCount.incrementDuration(trace.durationNs);
+		if (!trace.fullQueryCacheHit && trace.cachePolicy?.maxAgeNs != null) switch (trace.cachePolicy.scope) {
+			case _apollo_usage_reporting_protobuf.Trace.CachePolicy.Scope.PRIVATE:
+				this.queryLatencyStats.privateCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs);
+				break;
+			case _apollo_usage_reporting_protobuf.Trace.CachePolicy.Scope.PUBLIC:
+				this.queryLatencyStats.publicCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs);
+				break;
+		}
+		if (trace.persistedQueryHit) this.queryLatencyStats.persistedQueryHits++;
+		if (trace.persistedQueryRegister) this.queryLatencyStats.persistedQueryMisses++;
+		if (trace.forbiddenOperation) this.queryLatencyStats.forbiddenOperationCount++;
+		if (trace.registeredOperation) this.queryLatencyStats.registeredOperationCount++;
+		let hasError = false;
+		const errorPathStats = /* @__PURE__ */ new Set();
+		const traceNodeStats = (node, path) => {
+			if (node.error?.length) {
+				hasError = true;
+				let currPathErrorStats = this.queryLatencyStats.rootErrorStats;
+				path.toArray().forEach((subPath) => {
+					currPathErrorStats = currPathErrorStats.getChild(subPath, sizeEstimator);
+				});
+				errorPathStats.add(currPathErrorStats);
+				currPathErrorStats.errorsCount += node.error.length;
+			}
+			if (fieldExecutionWeight) {
+				const fieldName = node.originalFieldName || node.responseName;
+				if (node.parentType && fieldName && node.type && node.endTime != null && node.startTime != null && node.endTime >= node.startTime) {
+					const fieldStat = this.getTypeStat(node.parentType, sizeEstimator).getFieldStat(fieldName, node.type, sizeEstimator);
+					fieldStat.errorsCount += node.error?.length ?? 0;
+					fieldStat.observedExecutionCount++;
+					fieldStat.estimatedExecutionCount += fieldExecutionWeight;
+					fieldStat.requestsWithErrorsCount += (node.error?.length ?? 0) > 0 ? 1 : 0;
+					fieldStat.latencyCount.incrementDuration(node.endTime - node.startTime, fieldExecutionWeight);
+				}
+			}
+			return false;
+		};
+		iterateOverTrace(trace, traceNodeStats, true);
+		for (const { subgraph, path } of nonFtv1ErrorPaths) {
+			hasError = true;
+			if (path) {
+				let currPathErrorStats = this.queryLatencyStats.rootErrorStats.getChild(`service:${subgraph}`, sizeEstimator);
+				path.forEach((subPath) => {
+					if (typeof subPath === "string") currPathErrorStats = currPathErrorStats.getChild(subPath, sizeEstimator);
+				});
+				errorPathStats.add(currPathErrorStats);
+				currPathErrorStats.errorsCount += 1;
+			}
+		}
+		for (const errorPath of errorPathStats) errorPath.requestsWithErrorsCount += 1;
+		if (hasError) this.queryLatencyStats.requestsWithErrorsCount++;
+	}
+	getTypeStat(parentType, sizeEstimator) {
+		const existing = this.perTypeStat[parentType];
+		if (existing) return existing;
+		sizeEstimator.bytes += estimatedBytesForString(parentType);
+		const typeStat = new OurTypeStat();
+		this.perTypeStat[parentType] = typeStat;
+		return typeStat;
+	}
+};
+var OurQueryLatencyStats = class {
+	latencyCount = new DurationHistogram();
+	requestCount = 0;
+	requestsWithoutFieldInstrumentation = 0;
+	cacheHits = 0;
+	persistedQueryHits = 0;
+	persistedQueryMisses = 0;
+	cacheLatencyCount = new DurationHistogram();
+	rootErrorStats = new OurPathErrorStats();
+	requestsWithErrorsCount = 0;
+	publicCacheTtlCount = new DurationHistogram();
+	privateCacheTtlCount = new DurationHistogram();
+	registeredOperationCount = 0;
+	forbiddenOperationCount = 0;
+};
+var OurPathErrorStats = class OurPathErrorStats {
+	children = Object.create(null);
+	errorsCount = 0;
+	requestsWithErrorsCount = 0;
+	getChild(subPath, sizeEstimator) {
+		const existing = this.children[subPath];
+		if (existing) return existing;
+		const child = new OurPathErrorStats();
+		this.children[subPath] = child;
+		sizeEstimator.bytes += estimatedBytesForString(subPath) + 4;
+		return child;
+	}
+};
+var OurTypeStat = class {
+	perFieldStat = Object.create(null);
+	getFieldStat(fieldName, returnType, sizeEstimator) {
+		const existing = this.perFieldStat[fieldName];
+		if (existing) return existing;
+		sizeEstimator.bytes += estimatedBytesForString(fieldName) + estimatedBytesForString(returnType) + 10;
+		const fieldStat = new OurFieldStat(returnType);
+		this.perFieldStat[fieldName] = fieldStat;
+		return fieldStat;
+	}
+	ensureCountsAreIntegers() {
+		for (const fieldStat of Object.values(this.perFieldStat)) fieldStat.ensureCountsAreIntegers();
+	}
+};
+var OurFieldStat = class {
+	errorsCount = 0;
+	observedExecutionCount = 0;
+	estimatedExecutionCount = 0;
+	requestsWithErrorsCount = 0;
+	latencyCount = new DurationHistogram();
+	constructor(returnType) {
+		this.returnType = returnType;
+	}
+	ensureCountsAreIntegers() {
+		this.estimatedExecutionCount = Math.floor(this.estimatedExecutionCount);
+	}
+};
+function estimatedBytesForString(s) {
+	return 2 + Buffer.byteLength(s);
+}
+var DurationHistogram = class DurationHistogram {
+	buckets;
+	static BUCKET_COUNT = 384;
+	static EXPONENT_LOG = Math.log(1.1);
+	toArray() {
+		let bufferedZeroes = 0;
+		const outputArray = [];
+		for (const value of this.buckets) if (value === 0) bufferedZeroes++;
+		else {
+			if (bufferedZeroes === 1) outputArray.push(0);
+			else if (bufferedZeroes !== 0) outputArray.push(-bufferedZeroes);
+			outputArray.push(Math.floor(value));
+			bufferedZeroes = 0;
+		}
+		return outputArray;
+	}
+	static durationToBucket(durationNs) {
+		const log = Math.log(durationNs / 1e3);
+		const unboundedBucket = Math.ceil(log / DurationHistogram.EXPONENT_LOG);
+		return unboundedBucket <= 0 || Number.isNaN(unboundedBucket) ? 0 : unboundedBucket >= DurationHistogram.BUCKET_COUNT ? DurationHistogram.BUCKET_COUNT - 1 : unboundedBucket;
+	}
+	incrementDuration(durationNs, value = 1) {
+		this.incrementBucket(DurationHistogram.durationToBucket(durationNs), value);
+		return this;
+	}
+	incrementBucket(bucket, value = 1) {
+		if (bucket >= DurationHistogram.BUCKET_COUNT) throw Error("Bucket is out of bounds of the buckets array");
+		if (bucket >= this.buckets.length) {
+			const oldLength = this.buckets.length;
+			this.buckets.length = bucket + 1;
+			this.buckets.fill(0, oldLength);
+		}
+		this.buckets[bucket] += value;
+	}
+	combine(otherHistogram) {
+		for (let i = 0; i < otherHistogram.buckets.length; i++) this.incrementBucket(i, otherHistogram.buckets[i]);
+	}
+	constructor(options) {
+		const initSize = options?.initSize || 74;
+		const buckets = options?.buckets;
+		const arrayInitSize = Math.max(buckets?.length || 0, initSize);
+		this.buckets = Array(arrayInitSize).fill(0);
+		if (buckets) buckets.forEach((val, index) => this.buckets[index] = val);
+	}
+};
+/**
+* Iterates over the entire trace, calling `f` on each Trace.Node found. It
+* looks under the "root" node as well as any inside the query plan. If any `f`
+* returns true, it stops walking the tree.
+*
+* Each call to `f` will receive an object that implements ResponseNamePath. If
+* `includePath` is true, `f` can call `toArray()` on it to convert the
+* linked-list representation to an array of the response name (field name)
+* nodes that you navigate to get to the node (including a "service:subgraph"
+* top-level node if this is a federated trace). Note that we don't add anything
+* to the path for index (list element) nodes. This is because the only use case
+* we have (error path statistics) does not care about list indexes (it's not
+* that interesting to know that sometimes an error was at foo.3.bar and
+* sometimes foo.5.bar, vs just generally foo.bar).
+*
+* If `includePath` is false, we don't bother to build up the linked lists, and
+* calling `toArray()` will throw.
+*/
+function iterateOverTrace(trace, f, includePath) {
+	const rootPath = includePath ? new RootCollectingPathsResponseNamePath() : notCollectingPathsResponseNamePath;
+	if (trace.root) {
+		if (iterateOverTraceNode(trace.root, rootPath, f)) return;
+	}
+	if (trace.queryPlan) {
+		if (iterateOverQueryPlan(trace.queryPlan, rootPath, f)) return;
+	}
+}
+function iterateOverQueryPlan(node, rootPath, f) {
+	if (!node) return false;
+	if (node.fetch?.trace?.root && node.fetch.serviceName) return iterateOverTraceNode(node.fetch.trace.root, rootPath.child(`service:${node.fetch.serviceName}`), f);
+	if (node.flatten?.node) return iterateOverQueryPlan(node.flatten.node, rootPath, f);
+	if (node.parallel?.nodes) return node.parallel.nodes.some((node$1) => iterateOverQueryPlan(node$1, rootPath, f));
+	if (node.sequence?.nodes) return node.sequence.nodes.some((node$1) => iterateOverQueryPlan(node$1, rootPath, f));
+	return false;
+}
+function iterateOverTraceNode(node, path, f) {
+	if (f(node, path)) return true;
+	return node.child?.some((child) => {
+		return iterateOverTraceNode(child, child.responseName ? path.child(child.responseName) : path, f);
+	}) ?? false;
+}
+const notCollectingPathsResponseNamePath = {
+	toArray() {
+		throw Error("not collecting paths!");
+	},
+	child() {
+		return this;
+	}
+};
+var RootCollectingPathsResponseNamePath = class {
+	toArray() {
+		return [];
+	}
+	child(responseName) {
+		return new ChildCollectingPathsResponseNamePath(responseName, this);
+	}
+};
+var ChildCollectingPathsResponseNamePath = class ChildCollectingPathsResponseNamePath {
+	constructor(responseName, prev) {
+		this.responseName = responseName;
+		this.prev = prev;
+	}
+	toArray() {
+		const out = [];
+		let curr = this;
+		while (curr instanceof ChildCollectingPathsResponseNamePath) {
+			out.push(curr.responseName);
+			curr = curr.prev;
+		}
+		return out.reverse();
+	}
+	child(responseName) {
+		return new ChildCollectingPathsResponseNamePath(responseName, this);
+	}
+};
+
+//#endregion
+exports.OurReport = OurReport;

package/dist/stats.d.cts

@@ -0,0 +1,123 @@
+import { ReferencedFieldsByType } from "@apollo/utils.usagereporting";
+import { IContextualizedStats, IFieldStat, IPathErrorStats, IQueryLatencyStats, IReport, IStatsContext, ITracesAndStats, ITypeStat, ReportHeader, Trace, google } from "@apollo/usage-reporting-protobuf";
+import { NonFtv1ErrorPath } from "@apollo/server-gateway-interface";
+
+//#region src/stats.d.ts
+declare class SizeEstimator {
+  bytes: number;
+}
+declare class OurReport implements Required<IReport> {
+  readonly header: ReportHeader;
+  tracesPreAggregated: boolean;
+  constructor(header: ReportHeader);
+  readonly tracesPerQuery: Record<string, OurTracesAndStats>;
+  endTime: google.protobuf.ITimestamp | null;
+  operationCount: number;
+  readonly sizeEstimator: SizeEstimator;
+  ensureCountsAreIntegers(): void;
+  addTrace({
+    statsReportKey,
+    trace,
+    asTrace,
+    referencedFieldsByType,
+    maxTraceBytes,
+    nonFtv1ErrorPaths
+  }: {
+    statsReportKey: string;
+    trace: Trace;
+    asTrace: boolean;
+    referencedFieldsByType: ReferencedFieldsByType;
+    maxTraceBytes?: number;
+    nonFtv1ErrorPaths: NonFtv1ErrorPath[];
+  }): void;
+  private getTracesAndStats;
+}
+declare class OurTracesAndStats implements Required<ITracesAndStats> {
+  readonly referencedFieldsByType: ReferencedFieldsByType;
+  constructor(referencedFieldsByType: ReferencedFieldsByType);
+  readonly trace: Uint8Array[];
+  readonly statsWithContext: StatsByContext;
+  readonly internalTracesContributingToStats: Uint8Array[];
+  ensureCountsAreIntegers(): void;
+}
+declare class StatsByContext {
+  readonly map: {
+    [k: string]: OurContextualizedStats;
+  };
+  /**
+   * This function is used by the protobuf generator to convert this map into
+   * an array of contextualized stats to serialize
+   */
+  toArray(): IContextualizedStats[];
+  ensureCountsAreIntegers(): void;
+  addTrace(trace: Trace, sizeEstimator: SizeEstimator, nonFtv1ErrorPaths: NonFtv1ErrorPath[]): void;
+  private getContextualizedStats;
+}
+declare class OurContextualizedStats implements Required<IContextualizedStats> {
+  readonly context: IStatsContext;
+  queryLatencyStats: OurQueryLatencyStats;
+  perTypeStat: {
+    [k: string]: OurTypeStat;
+  };
+  constructor(context: IStatsContext);
+  ensureCountsAreIntegers(): void;
+  addTrace(trace: Trace, sizeEstimator: SizeEstimator, nonFtv1ErrorPaths?: NonFtv1ErrorPath[]): void;
+  getTypeStat(parentType: string, sizeEstimator: SizeEstimator): OurTypeStat;
+}
+declare class OurQueryLatencyStats implements Required<IQueryLatencyStats> {
+  latencyCount: DurationHistogram;
+  requestCount: number;
+  requestsWithoutFieldInstrumentation: number;
+  cacheHits: number;
+  persistedQueryHits: number;
+  persistedQueryMisses: number;
+  cacheLatencyCount: DurationHistogram;
+  rootErrorStats: OurPathErrorStats;
+  requestsWithErrorsCount: number;
+  publicCacheTtlCount: DurationHistogram;
+  privateCacheTtlCount: DurationHistogram;
+  registeredOperationCount: number;
+  forbiddenOperationCount: number;
+}
+declare class OurPathErrorStats implements Required<IPathErrorStats> {
+  children: {
+    [k: string]: OurPathErrorStats;
+  };
+  errorsCount: number;
+  requestsWithErrorsCount: number;
+  getChild(subPath: string, sizeEstimator: SizeEstimator): OurPathErrorStats;
+}
+declare class OurTypeStat implements Required<ITypeStat> {
+  perFieldStat: {
+    [k: string]: OurFieldStat;
+  };
+  getFieldStat(fieldName: string, returnType: string, sizeEstimator: SizeEstimator): OurFieldStat;
+  ensureCountsAreIntegers(): void;
+}
+declare class OurFieldStat implements Required<IFieldStat> {
+  readonly returnType: string;
+  errorsCount: number;
+  observedExecutionCount: number;
+  estimatedExecutionCount: number;
+  requestsWithErrorsCount: number;
+  latencyCount: DurationHistogram;
+  constructor(returnType: string);
+  ensureCountsAreIntegers(): void;
+}
+interface DurationHistogramOptions {
+  initSize?: number;
+  buckets?: number[];
+}
+declare class DurationHistogram {
+  private readonly buckets;
+  static readonly BUCKET_COUNT = 384;
+  static readonly EXPONENT_LOG: number;
+  toArray(): number[];
+  static durationToBucket(durationNs: number): number;
+  incrementDuration(durationNs: number, value?: number): DurationHistogram;
+  incrementBucket(bucket: number, value?: number): void;
+  combine(otherHistogram: DurationHistogram): void;
+  constructor(options?: DurationHistogramOptions);
+}
+//#endregion
+export { OurReport };