@faststore/api 2.0.163-alpha.0 → 2.0.165-alpha.0

package/dist/api.esm.js

@@ -4,12 +4,21 @@ import DataLoader from 'dataloader';
 import pLimit from 'p-limit';
 import deepEquals from 'fast-deep-equal';
 import crypto from 'crypto';
-import { GraphQLScalarType, print } from 'graphql';
+import { GraphQLScalarType, print, Kind as Kind$1 } from 'graphql';
 import { Kind } from 'graphql/language';
 import { mapSchema, MapperKind, getDirective } from '@graphql-tools/utils';
+import { BasicTracerProvider, SimpleSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
+import { Resource } from '@opentelemetry/resources';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { LoggerProvider, SimpleLogRecordProcessor, ConsoleLogRecordExporter } from '@opentelemetry/sdk-logs';
+import { OTLPLogsExporter } from '@opentelemetry/exporter-logs-otlp-grpc';
+import { isAsyncIterable } from '@envelop/core';
+import { useOnResolve } from '@envelop/on-resolve';
+import { trace, context, SpanKind } from '@opentelemetry/api';
+import { SeverityNumber } from '@opentelemetry/api-logs';
 
 var name = "@faststore/api";
-var version = "2.0.162-alpha.0";
+var version = "2.0.163-alpha.0";
 var license = "MIT";
 var main = "dist/index.js";
 var typings = "dist/index.d.ts";
@@ -31,7 +40,12 @@ var scripts = {
 	generate: "graphql-codegen --config codegen.yml"
 };
 var dependencies = {
+	"@envelop/on-resolve": "^2.0.6",
 	"@graphql-tools/schema": "^8.2.0",
+	"@opentelemetry/exporter-logs-otlp-grpc": "^0.39.1",
+	"@opentelemetry/exporter-trace-otlp-grpc": "^0.39.1",
+	"@opentelemetry/sdk-logs": "^0.39.1",
+	"@opentelemetry/sdk-trace-base": "^1.13.0",
 	"@rollup/plugin-graphql": "^1.0.0",
 	dataloader: "^2.1.0",
 	"fast-deep-equal": "^3.1.3",
@@ -41,6 +55,7 @@ var dependencies = {
 var devDependencies = {
 	"@faststore/eslint-config": "^2.0.104-alpha.0",
 	"@faststore/shared": "^2.0.104-alpha.0",
+	"@envelop/core": "^2.6.0",
 	"@graphql-codegen/cli": "2.2.0",
 	"@graphql-codegen/typescript": "2.2.2",
 	"@types/express": "^4.17.16",
@@ -56,6 +71,7 @@ var devDependencies = {
 	typescript: "^4.4.2"
 };
 var peerDependencies = {
+	"@envelop/core": "^1 || ^2",
 	graphql: "^15.6.0"
 };
 var packageJson = {
@@ -2528,6 +2544,242 @@ const directive = {
   })
 };
 
+var AttributeName;
+(function (AttributeName) {
+  AttributeName["EXECUTION_ERROR"] = "graphql.error";
+  AttributeName["EXECUTION_RESULT"] = "graphql.result";
+  AttributeName["RESOLVER_EXECUTION_ERROR"] = "graphql.resolver.error";
+  AttributeName["RESOLVER_EXCEPTION"] = "graphql.resolver.exception";
+  AttributeName["RESOLVER_FIELD_NAME"] = "graphql.resolver.fieldName";
+  AttributeName["RESOLVER_TYPE_NAME"] = "graphql.resolver.typeName";
+  AttributeName["RESOLVER_RESULT_TYPE"] = "graphql.resolver.resultType";
+  AttributeName["RESOLVER_ARGS"] = "graphql.resolver.args";
+  AttributeName["EXECUTION_OPERATION_NAME"] = "graphql.operation.name";
+  AttributeName["EXECUTION_OPERATION_TYPE"] = "graphql.operation.type";
+  AttributeName["EXECUTION_OPERATION_DOCUMENT"] = "graphql.document";
+  AttributeName["EXECUTION_VARIABLES"] = "graphql.variables";
+})(AttributeName || (AttributeName = {}));
+const tracingSpanSymbol = /*#__PURE__*/Symbol('OPEN_TELEMETRY_GRAPHQL');
+function getResolverSpanKey(path) {
+  const nodes = [];
+  // If the first node (after reversed, it will be the last one) is an integer, that is, identifies a list,
+  // we don't want to include it in the key. Note that this will only happen when analysing .prev paths in
+  // a list of elements. We just want to remove the initial node that is a integer, not all of them.
+  //
+  // Nodes with keys 6bc73341b2a183fc::product::image::0::url would not be able to find
+  // parents with key 6bc73341b2a183fc::product::image because of the "0" list index -
+  // it would search for 6bc73341b2a183fc::product::image::0
+  let currentPath = nodes.length === 0 && Number.isInteger(path.key) ? path.prev : path;
+  while (currentPath) {
+    nodes.push(currentPath.key);
+    currentPath = currentPath.prev;
+  }
+  return [...nodes].reverse().join('.');
+}
+const getFaststoreTelemetryPlugin = (tracingProvider, loggerProvider, serviceName, experimentalSendLogs) => {
+  return function useFaststoreTelemetry() {
+    const tracer = tracingProvider.getTracer(serviceName);
+    const logger = loggerProvider.getLogger(serviceName);
+    const resolverContextsByRootSpans = {};
+    return {
+      onPluginInit({
+        addPlugin
+      }) {
+        addPlugin(
+        // eslint-disable-next-line
+        useOnResolve(({
+          info,
+          context: context$1
+        }) => {
+          if (context$1 && typeof context$1 === 'object' && context$1[tracingSpanSymbol]) {
+            var _path$prev, _path$prev2;
+            tracer.getActiveSpanProcessor();
+            const rootContextSpanId = context$1[tracingSpanSymbol].spanContext().spanId;
+            const {
+              fieldName,
+              returnType,
+              parentType,
+              path
+            } = info;
+            const previousResolverSpanKey = path.prev && getResolverSpanKey(path.prev);
+            let ctx = null;
+            if (previousResolverSpanKey && resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey]) {
+              ctx = resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey];
+            } else {
+              var _resolverContextsByRo;
+              ctx = trace.setSpan(context.active(), context$1[tracingSpanSymbol]);
+              resolverContextsByRootSpans[rootContextSpanId] = (_resolverContextsByRo = resolverContextsByRootSpans[rootContextSpanId]) != null ? _resolverContextsByRo : {};
+            }
+            const resolverIndexInList = Number.isInteger((_path$prev = path.prev) == null ? void 0 : _path$prev.key) ? `[${(_path$prev2 = path.prev) == null ? void 0 : _path$prev2.key}]` : '';
+            const resolverSpan = tracer.startSpan(`${parentType.toString()}.${fieldName}${resolverIndexInList}`, {
+              attributes: {
+                [AttributeName.RESOLVER_FIELD_NAME]: fieldName,
+                [AttributeName.RESOLVER_TYPE_NAME]: parentType.toString(),
+                [AttributeName.RESOLVER_RESULT_TYPE]: returnType.toString(),
+                'meta.span.path': getResolverSpanKey(path)
+              }
+            }, ctx);
+            const resolverCtx = trace.setSpan(ctx, resolverSpan);
+            resolverContextsByRootSpans[rootContextSpanId][getResolverSpanKey(path)] = resolverCtx;
+            return ({
+              result
+            }) => {
+              if (result instanceof Error) {
+                resolverSpan.setAttributes({
+                  error: true,
+                  'exception.category': AttributeName.RESOLVER_EXECUTION_ERROR,
+                  'exception.message': result.message,
+                  'exception.type': result.name
+                });
+                resolverSpan.recordException(result);
+              }
+              resolverSpan.end();
+            };
+          }
+          return () => {};
+        }));
+      },
+      onExecute({
+        args,
+        extendContext
+      }) {
+        var _args$document$defini, _args$operationName;
+        const operationType = (_args$document$defini = args.document.definitions.filter(def => def.kind === Kind$1.OPERATION_DEFINITION).map(def => def.operation)) == null ? void 0 : _args$document$defini[0];
+        // Span name according to Semantic Conventions
+        // https://github.com/open-telemetry/semantic-conventions
+        let spanName = 'GraphQL Operation';
+        if (operationType && args.operationName) {
+          spanName = `${operationType} ${args.operationName}`;
+        } else if (operationType && !args.operationName) {
+          spanName = operationType;
+        }
+        const executionSpan = tracer.startSpan(spanName, {
+          kind: SpanKind.SERVER,
+          attributes: {
+            [AttributeName.EXECUTION_OPERATION_NAME]: (_args$operationName = args.operationName) != null ? _args$operationName : undefined,
+            [AttributeName.EXECUTION_OPERATION_TYPE]: operationType != null ? operationType : undefined,
+            [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(args.document)
+          }
+        });
+        const executeContext = context.active();
+        const resultCbs = {
+          onExecuteDone({
+            result
+          }) {
+            var _args$operationName2, _args$variableValues;
+            if (isAsyncIterable(result)) {
+              executionSpan.end();
+              // eslint-disable-next-line no-console
+              console.warn(`Plugin "newrelic" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
+              return;
+            }
+            const logRecord = {
+              context: executeContext,
+              attributes: {
+                'service.name': 'faststore-api',
+                'service.version': '1.12.38',
+                'service.name_and_version': 'faststore-api@1.12.38',
+                'vtex.search_index': 'faststore_beta_api',
+                [AttributeName.EXECUTION_OPERATION_NAME]: (_args$operationName2 = args.operationName) != null ? _args$operationName2 : undefined,
+                [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(args.document),
+                [AttributeName.EXECUTION_VARIABLES]: JSON.stringify((_args$variableValues = args.variableValues) != null ? _args$variableValues : {})
+              }
+            };
+            if (typeof result.data !== 'undefined' && !(result.errors && result.errors.length > 0)) {
+              logRecord.severityNumber = SeverityNumber.INFO;
+              logRecord.severityText = 'Info';
+              logRecord.attributes[AttributeName.EXECUTION_RESULT] = JSON.stringify(result);
+            }
+            if (result.errors && result.errors.length > 0) {
+              logRecord.severityNumber = SeverityNumber.ERROR;
+              logRecord.severityText = 'Error';
+              logRecord.attributes[AttributeName.EXECUTION_ERROR] = JSON.stringify(result.errors);
+              executionSpan.setAttributes({
+                error: true,
+                'exception.category': AttributeName.EXECUTION_ERROR,
+                'exception.message': JSON.stringify(result.errors)
+              });
+            }
+            if (experimentalSendLogs) {
+              logger.emit(logRecord);
+            }
+            executionSpan.end();
+          }
+        };
+        extendContext({
+          [tracingSpanSymbol]: executionSpan
+        });
+        return resultCbs;
+      }
+    };
+  };
+};
+
+const FASTSTORE_API_VERSION = packageJson.version;
+// TODO: These urls are hardcoded for now, but they should be configurable via ENV variables
+// They are only acessible from within the VTEX network, so they are not a security risk
+const TRACE_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+const TRACE_COLLECTOR_URL_DEV = 'opentelemetry-collector-beta.vtex.systems';
+const LOG_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+function getTelemetry(APIOptions, telemetryOptions) {
+  var _telemetryOptions$exp;
+  const honeycombCollectorOptions = {
+    url: (telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'dev' ? TRACE_COLLECTOR_URL_DEV : TRACE_COLLECTOR_URL
+  };
+  const openSearchCollectorOptions = {
+    url: LOG_COLLECTOR_URL
+  };
+  // Create a new tracer provider
+  const tracerProvider = new BasicTracerProvider({
+    resource: new Resource({
+      'service.name': 'faststore-api',
+      'service.version': FASTSTORE_API_VERSION,
+      'service.name_and_version': `faststore-api@${FASTSTORE_API_VERSION}`,
+      platform: APIOptions.platform,
+      [`${APIOptions.platform}.account`]: APIOptions.account,
+      [`${APIOptions.platform}.environment`]: APIOptions.environment,
+      // TODO: include the following properties in the logs
+      // [`${APIOptions.platform}.options.hideUnavailableItems`]:
+      //   APIOptions.hideUnavailableItems,
+      // [`${APIOptions.platform}.flags.enableOrderFormSync`]:
+      //   APIOptions.flags?.enableOrderFormSync,
+      // channel: APIOptions.channel,
+      locale: APIOptions.locale
+    })
+  });
+  const loggerProvider = new LoggerProvider();
+  // Create trace exporter
+  const honeycombExporter = new OTLPTraceExporter(honeycombCollectorOptions);
+  // Create log exporter
+  const openSearchExporter = new OTLPLogsExporter(openSearchCollectorOptions);
+  // Set up a span processor to export spans to Honeycomb
+  const honeyCombSpanProcessor = new SimpleSpanProcessor(honeycombExporter);
+  // Set up a log record processor to export spans to OpenSearch
+  const openSearchLogProcessor = new SimpleLogRecordProcessor(openSearchExporter);
+  // Register the span processor with the tracer provider
+  tracerProvider.addSpanProcessor(honeyCombSpanProcessor);
+  // Register the log record processor with the log provider
+  loggerProvider.addLogRecordProcessor(openSearchLogProcessor);
+  if ((telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'verbose' || (telemetryOptions == null ? void 0 : telemetryOptions.mode) === 'dev') {
+    // Set up a console exporter for verbose mode
+    const consoleExporter = new ConsoleSpanExporter();
+    const verboseTraceProcessor = new SimpleSpanProcessor(consoleExporter);
+    // Set up processors for verbose mode
+    const consoleLogExporter = new ConsoleLogRecordExporter();
+    const veboseLogRecordExporter = new SimpleLogRecordProcessor(consoleLogExporter);
+    tracerProvider.addSpanProcessor(verboseTraceProcessor);
+    loggerProvider.addLogRecordProcessor(veboseLogRecordExporter);
+  }
+  const useFaststoreTelemetry = getFaststoreTelemetryPlugin(
+  // The @opentelemetry/sdk-trace-base was renamed from @opentelemetry/tracing but the
+  // envelop plugin doesn't support this change yet. This causes the class type to be incompatible,
+  // even if they are the same. https://github.com/n1ru4l/envelop/issues/1610
+  tracerProvider, loggerProvider, 'faststore-api', (_telemetryOptions$exp = telemetryOptions == null ? void 0 : telemetryOptions.experimentalSendLogs) != null ? _telemetryOptions$exp : false);
+  return {
+    useFaststoreTelemetry
+  };
+}
+
 const platforms = {
   vtex: {
     getResolvers: getResolvers,
@@ -2546,5 +2798,5 @@ const getSchema = async options => {
   return directives.reduce((s, d) => d.transformer(s), schema);
 };
 
-export { BadRequestError, NotFoundError, getContextFactory$1 as getContextFactory, getResolvers$1 as getResolvers, getSchema, getTypeDefs, isBadRequestError, isFastStoreError, isNotFoundError, stringify$1 as stringifyCacheControl };
+export { BadRequestError, NotFoundError, getContextFactory$1 as getContextFactory, getResolvers$1 as getResolvers, getSchema, getTelemetry, getTypeDefs, isBadRequestError, isFastStoreError, isNotFoundError, stringify$1 as stringifyCacheControl };
 //# sourceMappingURL=api.esm.js.map