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

package/esm/index.js

@@ -1,182 +0,0 @@
-import { getOperationAST, Kind } 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';
-import { getEnvVar, Reporter } from './reporter.js';
-export 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);
-        }
-        // We don't want to block server start even if we failed to compute schema id
-        schemaIdSet$ = undefined;
-    };
-    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) {
-                        // When the schema is static, the `onSchemaChange` hook is called before initialization
-                        // We have to handle schema loading here in this case.
-                        const { schema } = yoga.getEnveloped();
-                        if (schema) {
-                            schemaIdSet$ = setCurrentSchema(schema);
-                        }
-                    }
-                },
-                onSchemaChange({ schema }) {
-                    // When the schema is static, this hook is called before yoga initialization
-                    // Since we need yoga.fetchAPI for id calculation, we need to wait for Yoga init
-                    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) {
-                            // To make sure the trace will not be sent, remove request's tracing context
-                            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 {
-                            // To make sure the trace will not be sent, remove request's tracing context
-                            ctxForReq.delete(context.request);
-                        }
-                    };
-                },
-                onResultProcess({ request, result, serverContext }) {
-                    // TODO: Handle async iterables ?
-                    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, // TODO: allow to not always send traces
-                            nonFtv1ErrorPaths: [],
-                            maxTraceBytes: options.maxTraceSize,
-                        }));
-                    }
-                },
-                async onDispose() {
-                    await reporter?.flush();
-                },
-            });
-        },
-    };
-}
-export 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) => !!data && typeof data === 'object';
-    return isObject(data) && data['kind'] === Kind.DOCUMENT;
-}

package/esm/reporter.js

@@ -1,136 +0,0 @@
-import { google, Report, ReportHeader } from '@apollo/usage-reporting-protobuf';
-import { OurReport } from './stats.js';
-const DEFAULT_REPORTING_ENDPOINT = 'https://usage-reporting.api.apollographql.com/api/ingress/traces';
-export class Reporter {
-    yoga;
-    logger;
-    reportHeaders;
-    options;
-    reportsBySchema = {};
-    nextSendAfterDelay;
-    sending = [];
-    constructor(options, yoga, logger) {
-        this.yoga = yoga;
-        this.logger = logger;
-        this.options = {
-            ...options,
-            maxBatchDelay: options.maxBatchDelay ?? 20_000, // 20s
-            maxBatchUncompressedSize: options.maxBatchUncompressedSize ?? 4 * 1024 * 1024, // 4mb
-            maxTraceSize: options.maxTraceSize ?? 10 * 1024 * 1024, // 10mb
-            exportTimeout: options.exportTimeout ?? 30_000, // 30s
-            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 ?? '', // TODO: find a cross-platform way to get the 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);
-        return;
-    }
-    async flush() {
-        return Promise.allSettled([
-            ...this.sending, // When flushing, we want to also wait for previous traces to be sent, because it's mostly used for clean up
-            ...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 = undefined;
-        }
-        delete this.reportsBySchema[schemaId];
-        report.endTime = dateToProtoTimestamp(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',
-                        // The presence of the api key is already checked at Yoga initialization time
-                        '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;
-}
-export function getEnvVar(name, defaultValue) {
-    return globalThis.process?.env?.[name] || defaultValue || undefined;
-}
-// Converts a JS Date into a Timestamp.
-export function dateToProtoTimestamp(date) {
-    const totalMillis = date.getTime();
-    const millis = totalMillis % 1000;
-    return new google.protobuf.Timestamp({
-        seconds: (totalMillis - millis) / 1000,
-        nanos: millis * 1e6,
-    });
-}