@graphql-yoga/plugin-apollo-usage-report 0.13.0 → 0.13.1-alpha-20260116132159-d18a95d04a1e11d197fdf672a8be4836ceed0818

package/dist/index.cjs

@@ -0,0 +1,152 @@
+const require_reporter = require('./reporter.cjs');
+let graphql = require("graphql");
+let graphql_yoga = require("graphql-yoga");
+let _apollo_utils_usagereporting = require("@apollo/utils.usagereporting");
+let _graphql_tools_utils = require("@graphql-tools/utils");
+let _graphql_yoga_plugin_apollo_inline_trace = require("@graphql-yoga/plugin-apollo-inline-trace");
+
+//#region src/index.ts
+function useApolloUsageReport(options = {}) {
+	const [instrumentation, ctxForReq] = (0, _graphql_yoga_plugin_apollo_inline_trace.useApolloInstrumentation)(options);
+	const makeReporter = options.reporter ?? ((...args) => new require_reporter.Reporter(...args));
+	let schemaIdSet$;
+	let currentSchema;
+	let yoga;
+	let reporter;
+	const setCurrentSchema = async (schema) => {
+		try {
+			currentSchema = {
+				id: await hashSHA256((0, _graphql_tools_utils.printSchemaWithDirectives)(schema), yoga.fetchAPI),
+				schema
+			};
+		} catch (error) {
+			logger.error("Failed to calculate schema hash: ", error);
+		}
+		schemaIdSet$ = void 0;
+	};
+	const logger = Object.fromEntries([
+		"error",
+		"warn",
+		"info",
+		"debug"
+	].map((level) => [level, (...messages) => yoga.logger[level]("[ApolloUsageReport]", ...messages)]));
+	let clientNameFactory = (req) => req.headers.get("apollographql-client-name");
+	if (typeof options.clientName === "function") clientNameFactory = options.clientName;
+	let clientVersionFactory = (req) => req.headers.get("apollographql-client-version");
+	if (typeof options.clientVersion === "function") clientVersionFactory = options.clientVersion;
+	return { onPluginInit({ addPlugin }) {
+		addPlugin(instrumentation);
+		addPlugin({
+			onYogaInit(args) {
+				yoga = args.yoga;
+				reporter = makeReporter(options, yoga, logger);
+				if (!require_reporter.getEnvVar("APOLLO_KEY", options.apiKey)) throw new Error(`[ApolloUsageReport] Missing API key. Please provide one in plugin options or with 'APOLLO_KEY' environment variable.`);
+				if (!require_reporter.getEnvVar("APOLLO_GRAPH_REF", options.graphRef)) throw new Error(`[ApolloUsageReport] Missing Graph Ref. Please provide one in plugin options or with 'APOLLO_GRAPH_REF' environment variable.`);
+				if (!schemaIdSet$ && !currentSchema) {
+					const { schema } = yoga.getEnveloped();
+					if (schema) schemaIdSet$ = setCurrentSchema(schema);
+				}
+			},
+			onSchemaChange({ schema }) {
+				if (schema && yoga) schemaIdSet$ = setCurrentSchema(schema);
+			},
+			onRequestParse() {
+				return schemaIdSet$;
+			},
+			onParse() {
+				return function onParseEnd({ result, context }) {
+					const ctx = ctxForReq.get(context.request)?.traces.get(context);
+					if (!ctx) {
+						logger.debug("operation tracing context not found, this operation will not be traced.");
+						return;
+					}
+					ctx.schemaId = currentSchema.id;
+					if (isDocumentNode(result)) {
+						if ((0, graphql.getOperationAST)(result, context.params.operationName)) return;
+						ctx.operationKey = `## GraphQLUnknownOperationName\n`;
+					} else ctx.operationKey = "## GraphQLParseFailure\n";
+					if (!options.sendUnexecutableOperationDocuments) {
+						ctxForReq.delete(context.request);
+						return;
+					}
+					ctx.trace.unexecutedOperationName = context.params.operationName || "";
+					ctx.trace.unexecutedOperationBody = context.params.query || "";
+				};
+			},
+			onValidate({ params: { documentAST: document } }) {
+				return ({ valid, context }) => {
+					const ctx = ctxForReq.get(context.request)?.traces.get(context);
+					if (!ctx) {
+						logger.debug("operation tracing context not found, this operation will not be traced.");
+						return;
+					}
+					if (valid) {
+						if (!currentSchema) throw new Error("should not happen: schema doesn't exists");
+						const opName = (0, graphql.getOperationAST)(document, context.params.operationName)?.name?.value;
+						ctx.referencedFieldsByType = (0, _apollo_utils_usagereporting.calculateReferencedFieldsByType)({
+							document,
+							schema: currentSchema.schema,
+							resolvedOperationName: opName ?? null
+						});
+						ctx.operationKey = `# ${opName || "-"}\n${(0, _apollo_utils_usagereporting.usageReportingSignature)(document, opName ?? "")}`;
+					} else if (options.sendUnexecutableOperationDocuments) {
+						ctx.operationKey = "## GraphQLValidationFailure\n";
+						ctx.trace.unexecutedOperationName = context.params.operationName ?? "";
+						ctx.trace.unexecutedOperationBody = context.params.query ?? "";
+					} else ctxForReq.delete(context.request);
+				};
+			},
+			onResultProcess({ request, result, serverContext }) {
+				if ((0, graphql_yoga.isAsyncIterable)(result)) {
+					logger.debug("async iterable results not implemented for now");
+					return;
+				}
+				const reqCtx = ctxForReq.get(request);
+				if (!reqCtx) {
+					logger.debug("operation tracing context not found, this operation will not be traced.");
+					return;
+				}
+				for (const trace of reqCtx.traces.values()) {
+					if (!trace.schemaId || !trace.operationKey) {
+						logger.debug("Misformed trace, missing operation key or schema id");
+						continue;
+					}
+					const clientName = clientNameFactory(request);
+					if (clientName) trace.trace.clientName = clientName;
+					const clientVersion = clientVersionFactory(request);
+					if (clientVersion) trace.trace.clientVersion = clientVersion;
+					serverContext.waitUntil(reporter.addTrace(currentSchema.id, {
+						statsReportKey: trace.operationKey,
+						trace: trace.trace,
+						referencedFieldsByType: trace.referencedFieldsByType ?? {},
+						asTrace: true,
+						nonFtv1ErrorPaths: [],
+						maxTraceBytes: options.maxTraceSize
+					}));
+				}
+			},
+			async onDispose() {
+				await reporter?.flush();
+			}
+		});
+	} };
+}
+async function hashSHA256(text, api = globalThis) {
+	const inputUint8Array = new api.TextEncoder().encode(text);
+	const arrayBuf = await api.crypto.subtle.digest({ name: "SHA-256" }, inputUint8Array);
+	const outputUint8Array = new Uint8Array(arrayBuf);
+	let hash = "";
+	for (const byte of outputUint8Array) {
+		const hex = byte.toString(16);
+		hash += "00".slice(0, Math.max(0, 2 - hex.length)) + hex;
+	}
+	return hash;
+}
+function isDocumentNode(data) {
+	const isObject = (data$1) => !!data$1 && typeof data$1 === "object";
+	return isObject(data) && data["kind"] === graphql.Kind.DOCUMENT;
+}
+
+//#endregion
+exports.hashSHA256 = hashSHA256;
+exports.useApolloUsageReport = useApolloUsageReport;

package/dist/index.d.cts

@@ -0,0 +1,125 @@
+import { Reporter } from "./reporter.cjs";
+import { Maybe, Plugin, YogaInitialContext, YogaLogger, YogaServer } from "graphql-yoga";
+import { calculateReferencedFieldsByType } from "@apollo/utils.usagereporting";
+import { ApolloInlineGraphqlTraceContext, ApolloInlineRequestTraceContext, ApolloInlineTracePluginOptions } from "@graphql-yoga/plugin-apollo-inline-trace";
+
+//#region src/index.d.ts
+type ApolloUsageReportOptions = ApolloInlineTracePluginOptions & {
+  /**
+   * The graph ref of the managed federation graph.
+   * It is composed of the graph ID and the variant (`<YOUR_GRAPH_ID>@<VARIANT>`).
+   *
+   * If not provided, `APOLLO_GRAPH_REF` environment variable is used.
+   *
+   * You can find a a graph's ref at the top of its Schema Reference page in Apollo Studio.
+   */
+  graphRef?: string;
+  /**
+   * The API key to use to authenticate with the managed federation up link.
+   * It needs at least the `service:read` permission.
+   *
+   * If not provided, `APOLLO_KEY` environment variable will be used instead.
+   *
+   * [Learn how to create an API key](https://www.apollographql.com/docs/federation/v1/managed-federation/setup#4-connect-the-gateway-to-studio)
+   */
+  apiKey?: string;
+  /**
+   * Usage report endpoint
+   *
+   * Defaults to GraphOS endpoint (https://usage-reporting.api.apollographql.com/api/ingress/traces)
+   */
+  endpoint?: string;
+  /**
+   * Agent Version to report to the usage reporting API
+   */
+  agentVersion?: string;
+  /**
+   * Client name to report to the usage reporting API
+   */
+  clientName?: StringFromRequestFn;
+  /**
+   * Client version to report to the usage reporting API
+   */
+  clientVersion?: StringFromRequestFn;
+  /**
+   * The version of the runtime (like 'node v23.7.0')
+   * @default empty string.
+   */
+  runtimeVersion?: string;
+  /**
+   * The hostname of the machine running this server
+   * @default $HOSTNAME environment variable
+   */
+  hostname?: string;
+  /**
+   * The OS identification string.
+   * The format is `${os.platform()}, ${os.type()}, ${os.release()}, ${os.arch()})`
+   * @default empty string
+   */
+  uname?: string;
+  /**
+   * The maximum estimated size of each traces in bytes. If the estimated size is higher than this threshold,
+   * the complete trace will not be sent and will be reduced to aggregated stats.
+   *
+   * Note: GraphOS only allow for traces of 10mb maximum
+   * @default 10 * 1024 * 1024 (10mb)
+   */
+  maxTraceSize?: number;
+  /**
+   * The maximum uncompressed size of a report in bytes.
+   * The report will be sent once this threshold is reached, even if the delay between send is not
+   * yet expired.
+   *
+   * @default 4Mb
+   */
+  maxBatchUncompressedSize?: number;
+  /**
+   * The maximum time in ms between reports.
+   * @default 20s
+   */
+  maxBatchDelay?: number;
+  /**
+   * Control if traces should be always sent.
+   * If false, the traces will be batched until a delay or size is reached.
+   * Note: This is highly not recommended in a production environment
+   *
+   * @default false
+   */
+  alwaysSend?: boolean;
+  /**
+   * Timeout in ms of a trace export tentative
+   * @default 30s
+   */
+  exportTimeout?: number;
+  /**
+   * The class to be used to keep track of traces and send them to the GraphOS endpoint
+   * Note: This option is aimed to be used for testing purposes
+   */
+  reporter?: (options: ApolloUsageReportOptions, yoga: YogaServer<Record<string, unknown>, Record<string, unknown>>, logger: YogaLogger) => Reporter;
+  /**
+   * Called when all retry attempts to send a report to GraphOS endpoint failed.
+   * By default, the error is logged.
+   */
+  onError?: (err: Error) => void;
+  /**
+   * If false, unexecutable operation (with parsing or validation error) will not be sent
+   * @default false
+   */
+  sendUnexecutableOperationDocuments?: boolean;
+};
+interface ApolloUsageReportRequestContext extends ApolloInlineRequestTraceContext {
+  traces: Map<YogaInitialContext, ApolloUsageReportGraphqlContext>;
+}
+interface ApolloUsageReportGraphqlContext extends ApolloInlineGraphqlTraceContext {
+  referencedFieldsByType?: ReturnType<typeof calculateReferencedFieldsByType>;
+  operationKey?: string;
+  schemaId?: string;
+}
+type StringFromRequestFn = (req: Request) => Maybe<string>;
+declare function useApolloUsageReport(options?: ApolloUsageReportOptions): Plugin;
+declare function hashSHA256(text: string, api?: {
+  crypto: Crypto;
+  TextEncoder: (typeof globalThis)['TextEncoder'];
+}): Promise<string>;
+//#endregion
+export { ApolloUsageReportGraphqlContext, ApolloUsageReportOptions, ApolloUsageReportRequestContext, hashSHA256, useApolloUsageReport };

package/dist/index.d.mts

@@ -0,0 +1,125 @@
+import { Reporter } from "./reporter.mjs";
+import { Maybe, Plugin, YogaInitialContext, YogaLogger, YogaServer } from "graphql-yoga";
+import { calculateReferencedFieldsByType } from "@apollo/utils.usagereporting";
+import { ApolloInlineGraphqlTraceContext, ApolloInlineRequestTraceContext, ApolloInlineTracePluginOptions } from "@graphql-yoga/plugin-apollo-inline-trace";
+
+//#region src/index.d.ts
+type ApolloUsageReportOptions = ApolloInlineTracePluginOptions & {
+  /**
+   * The graph ref of the managed federation graph.
+   * It is composed of the graph ID and the variant (`<YOUR_GRAPH_ID>@<VARIANT>`).
+   *
+   * If not provided, `APOLLO_GRAPH_REF` environment variable is used.
+   *
+   * You can find a a graph's ref at the top of its Schema Reference page in Apollo Studio.
+   */
+  graphRef?: string;
+  /**
+   * The API key to use to authenticate with the managed federation up link.
+   * It needs at least the `service:read` permission.
+   *
+   * If not provided, `APOLLO_KEY` environment variable will be used instead.
+   *
+   * [Learn how to create an API key](https://www.apollographql.com/docs/federation/v1/managed-federation/setup#4-connect-the-gateway-to-studio)
+   */
+  apiKey?: string;
+  /**
+   * Usage report endpoint
+   *
+   * Defaults to GraphOS endpoint (https://usage-reporting.api.apollographql.com/api/ingress/traces)
+   */
+  endpoint?: string;
+  /**
+   * Agent Version to report to the usage reporting API
+   */
+  agentVersion?: string;
+  /**
+   * Client name to report to the usage reporting API
+   */
+  clientName?: StringFromRequestFn;
+  /**
+   * Client version to report to the usage reporting API
+   */
+  clientVersion?: StringFromRequestFn;
+  /**
+   * The version of the runtime (like 'node v23.7.0')
+   * @default empty string.
+   */
+  runtimeVersion?: string;
+  /**
+   * The hostname of the machine running this server
+   * @default $HOSTNAME environment variable
+   */
+  hostname?: string;
+  /**
+   * The OS identification string.
+   * The format is `${os.platform()}, ${os.type()}, ${os.release()}, ${os.arch()})`
+   * @default empty string
+   */
+  uname?: string;
+  /**
+   * The maximum estimated size of each traces in bytes. If the estimated size is higher than this threshold,
+   * the complete trace will not be sent and will be reduced to aggregated stats.
+   *
+   * Note: GraphOS only allow for traces of 10mb maximum
+   * @default 10 * 1024 * 1024 (10mb)
+   */
+  maxTraceSize?: number;
+  /**
+   * The maximum uncompressed size of a report in bytes.
+   * The report will be sent once this threshold is reached, even if the delay between send is not
+   * yet expired.
+   *
+   * @default 4Mb
+   */
+  maxBatchUncompressedSize?: number;
+  /**
+   * The maximum time in ms between reports.
+   * @default 20s
+   */
+  maxBatchDelay?: number;
+  /**
+   * Control if traces should be always sent.
+   * If false, the traces will be batched until a delay or size is reached.
+   * Note: This is highly not recommended in a production environment
+   *
+   * @default false
+   */
+  alwaysSend?: boolean;
+  /**
+   * Timeout in ms of a trace export tentative
+   * @default 30s
+   */
+  exportTimeout?: number;
+  /**
+   * The class to be used to keep track of traces and send them to the GraphOS endpoint
+   * Note: This option is aimed to be used for testing purposes
+   */
+  reporter?: (options: ApolloUsageReportOptions, yoga: YogaServer<Record<string, unknown>, Record<string, unknown>>, logger: YogaLogger) => Reporter;
+  /**
+   * Called when all retry attempts to send a report to GraphOS endpoint failed.
+   * By default, the error is logged.
+   */
+  onError?: (err: Error) => void;
+  /**
+   * If false, unexecutable operation (with parsing or validation error) will not be sent
+   * @default false
+   */
+  sendUnexecutableOperationDocuments?: boolean;
+};
+interface ApolloUsageReportRequestContext extends ApolloInlineRequestTraceContext {
+  traces: Map<YogaInitialContext, ApolloUsageReportGraphqlContext>;
+}
+interface ApolloUsageReportGraphqlContext extends ApolloInlineGraphqlTraceContext {
+  referencedFieldsByType?: ReturnType<typeof calculateReferencedFieldsByType>;
+  operationKey?: string;
+  schemaId?: string;
+}
+type StringFromRequestFn = (req: Request) => Maybe<string>;
+declare function useApolloUsageReport(options?: ApolloUsageReportOptions): Plugin;
+declare function hashSHA256(text: string, api?: {
+  crypto: Crypto;
+  TextEncoder: (typeof globalThis)['TextEncoder'];
+}): Promise<string>;
+//#endregion
+export { ApolloUsageReportGraphqlContext, ApolloUsageReportOptions, ApolloUsageReportRequestContext, hashSHA256, useApolloUsageReport };

package/dist/index.mjs

@@ -0,0 +1,151 @@
+import { Reporter, getEnvVar } from "./reporter.mjs";
+import { Kind, getOperationAST } from "graphql";
+import { isAsyncIterable } from "graphql-yoga";
+import { calculateReferencedFieldsByType, usageReportingSignature } from "@apollo/utils.usagereporting";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { useApolloInstrumentation } from "@graphql-yoga/plugin-apollo-inline-trace";
+
+//#region src/index.ts
+function useApolloUsageReport(options = {}) {
+	const [instrumentation, ctxForReq] = useApolloInstrumentation(options);
+	const makeReporter = options.reporter ?? ((...args) => new Reporter(...args));
+	let schemaIdSet$;
+	let currentSchema;
+	let yoga;
+	let reporter;
+	const setCurrentSchema = async (schema) => {
+		try {
+			currentSchema = {
+				id: await hashSHA256(printSchemaWithDirectives(schema), yoga.fetchAPI),
+				schema
+			};
+		} catch (error) {
+			logger.error("Failed to calculate schema hash: ", error);
+		}
+		schemaIdSet$ = void 0;
+	};
+	const logger = Object.fromEntries([
+		"error",
+		"warn",
+		"info",
+		"debug"
+	].map((level) => [level, (...messages) => yoga.logger[level]("[ApolloUsageReport]", ...messages)]));
+	let clientNameFactory = (req) => req.headers.get("apollographql-client-name");
+	if (typeof options.clientName === "function") clientNameFactory = options.clientName;
+	let clientVersionFactory = (req) => req.headers.get("apollographql-client-version");
+	if (typeof options.clientVersion === "function") clientVersionFactory = options.clientVersion;
+	return { onPluginInit({ addPlugin }) {
+		addPlugin(instrumentation);
+		addPlugin({
+			onYogaInit(args) {
+				yoga = args.yoga;
+				reporter = makeReporter(options, yoga, logger);
+				if (!getEnvVar("APOLLO_KEY", options.apiKey)) throw new Error(`[ApolloUsageReport] Missing API key. Please provide one in plugin options or with 'APOLLO_KEY' environment variable.`);
+				if (!getEnvVar("APOLLO_GRAPH_REF", options.graphRef)) throw new Error(`[ApolloUsageReport] Missing Graph Ref. Please provide one in plugin options or with 'APOLLO_GRAPH_REF' environment variable.`);
+				if (!schemaIdSet$ && !currentSchema) {
+					const { schema } = yoga.getEnveloped();
+					if (schema) schemaIdSet$ = setCurrentSchema(schema);
+				}
+			},
+			onSchemaChange({ schema }) {
+				if (schema && yoga) schemaIdSet$ = setCurrentSchema(schema);
+			},
+			onRequestParse() {
+				return schemaIdSet$;
+			},
+			onParse() {
+				return function onParseEnd({ result, context }) {
+					const ctx = ctxForReq.get(context.request)?.traces.get(context);
+					if (!ctx) {
+						logger.debug("operation tracing context not found, this operation will not be traced.");
+						return;
+					}
+					ctx.schemaId = currentSchema.id;
+					if (isDocumentNode(result)) {
+						if (getOperationAST(result, context.params.operationName)) return;
+						ctx.operationKey = `## GraphQLUnknownOperationName\n`;
+					} else ctx.operationKey = "## GraphQLParseFailure\n";
+					if (!options.sendUnexecutableOperationDocuments) {
+						ctxForReq.delete(context.request);
+						return;
+					}
+					ctx.trace.unexecutedOperationName = context.params.operationName || "";
+					ctx.trace.unexecutedOperationBody = context.params.query || "";
+				};
+			},
+			onValidate({ params: { documentAST: document } }) {
+				return ({ valid, context }) => {
+					const ctx = ctxForReq.get(context.request)?.traces.get(context);
+					if (!ctx) {
+						logger.debug("operation tracing context not found, this operation will not be traced.");
+						return;
+					}
+					if (valid) {
+						if (!currentSchema) throw new Error("should not happen: schema doesn't exists");
+						const opName = getOperationAST(document, context.params.operationName)?.name?.value;
+						ctx.referencedFieldsByType = calculateReferencedFieldsByType({
+							document,
+							schema: currentSchema.schema,
+							resolvedOperationName: opName ?? null
+						});
+						ctx.operationKey = `# ${opName || "-"}\n${usageReportingSignature(document, opName ?? "")}`;
+					} else if (options.sendUnexecutableOperationDocuments) {
+						ctx.operationKey = "## GraphQLValidationFailure\n";
+						ctx.trace.unexecutedOperationName = context.params.operationName ?? "";
+						ctx.trace.unexecutedOperationBody = context.params.query ?? "";
+					} else ctxForReq.delete(context.request);
+				};
+			},
+			onResultProcess({ request, result, serverContext }) {
+				if (isAsyncIterable(result)) {
+					logger.debug("async iterable results not implemented for now");
+					return;
+				}
+				const reqCtx = ctxForReq.get(request);
+				if (!reqCtx) {
+					logger.debug("operation tracing context not found, this operation will not be traced.");
+					return;
+				}
+				for (const trace of reqCtx.traces.values()) {
+					if (!trace.schemaId || !trace.operationKey) {
+						logger.debug("Misformed trace, missing operation key or schema id");
+						continue;
+					}
+					const clientName = clientNameFactory(request);
+					if (clientName) trace.trace.clientName = clientName;
+					const clientVersion = clientVersionFactory(request);
+					if (clientVersion) trace.trace.clientVersion = clientVersion;
+					serverContext.waitUntil(reporter.addTrace(currentSchema.id, {
+						statsReportKey: trace.operationKey,
+						trace: trace.trace,
+						referencedFieldsByType: trace.referencedFieldsByType ?? {},
+						asTrace: true,
+						nonFtv1ErrorPaths: [],
+						maxTraceBytes: options.maxTraceSize
+					}));
+				}
+			},
+			async onDispose() {
+				await reporter?.flush();
+			}
+		});
+	} };
+}
+async function hashSHA256(text, api = globalThis) {
+	const inputUint8Array = new api.TextEncoder().encode(text);
+	const arrayBuf = await api.crypto.subtle.digest({ name: "SHA-256" }, inputUint8Array);
+	const outputUint8Array = new Uint8Array(arrayBuf);
+	let hash = "";
+	for (const byte of outputUint8Array) {
+		const hex = byte.toString(16);
+		hash += "00".slice(0, Math.max(0, 2 - hex.length)) + hex;
+	}
+	return hash;
+}
+function isDocumentNode(data) {
+	const isObject = (data$1) => !!data$1 && typeof data$1 === "object";
+	return isObject(data) && data["kind"] === Kind.DOCUMENT;
+}
+
+//#endregion
+export { hashSHA256, useApolloUsageReport };

package/dist/reporter.cjs

@@ -0,0 +1,118 @@
+const require_stats = require('./stats.cjs');
+let _apollo_usage_reporting_protobuf = require("@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 = _apollo_usage_reporting_protobuf.Report.verify(report);
+		if (validationError) throw new TypeError(`Invalid report: ${validationError}`);
+		const { apiKey = getEnvVar("APOLLO_KEY"), endpoint = DEFAULT_REPORTING_ENDPOINT } = this.options;
+		const encodedReport = _apollo_usage_reporting_protobuf.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 require_stats.OurReport(new _apollo_usage_reporting_protobuf.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 _apollo_usage_reporting_protobuf.google.protobuf.Timestamp({
+		seconds: (totalMillis - millis) / 1e3,
+		nanos: millis * 1e6
+	});
+}
+
+//#endregion
+exports.Reporter = Reporter;
+exports.getEnvVar = getEnvVar;