Skip to content

Supercharge your AI agents with data from the web and beyond. Building the library for superintelligence. 🔥

27.0 KB
Raw Blame
import { Response } from "express";
import { providerScrapeController } from "./scrape-alexandria";
import { discoverTools, usOnlyToolsWarning } from "../../search/alexandria";
import { config } from "../../config";
import { timingSafeSecretEqual } from "../../lib/secret-compare";
import { logger as _logger } from "../../lib/logger";
import {
  Document,
  FormatObject,
  RequestWithAuth,
  ScrapeRequest,
  scrapeRequestSchema,
  ScrapeResponse,
} from "./types";
import { v7 as uuidv7 } from "uuid";
import { hasFormatOfType } from "../../lib/format-utils";
import {
  getTimeoutProcessingDetails,
  TransportableError,
} from "../../lib/error";
import { ThirdPartyDataTermsRequiredError } from "../../lib/exchange";
import { NuQJob } from "../../services/worker/nuq";
import { checkPermissions } from "../../lib/permissions";
import {
  applySafeMode,
  resolveSafeMode,
  isLockdownZeroDataRetention,
} from "../../lib/safe-mode";
import {
  actionTypesOf,
  checkKeyFormatRestriction,
  formatTypesOf,
} from "../../lib/key-restriction";
import { withSpan, setSpanAttributes, SpanKind } from "../../lib/otel-tracer";
import { processJobInternal } from "../../services/worker/scrape-worker";
import { ScrapeJobData } from "../../types";
import { teamConcurrencySemaphore } from "../../services/worker/team-semaphore";
import { getJobPriority } from "../../lib/job-priority";
import { logRequest } from "../../services/logging/log_job";
import { externalRequestId } from "../../lib/external-request-id";
import { getErrorContactMessage } from "../../lib/deployment";
import type { BillingMetadata } from "../../services/billing/types";
import { getScrapeZDR } from "../../lib/zdr-helpers";
import {
  adjustKeylessCredits,
  keylessLimitBody,
  logKeylessCreditUsage,
  reserveKeylessCredits,
} from "../../lib/keyless";
import { projectScrapeCredits } from "../../lib/keyless-credit-projection";
import { applyAgentAuthDiscoveryHeader } from "../../lib/agent-auth-discovery";
import { resolveThreatProtection } from "../../lib/threat-protection/request";
import { emitRejectedScrapeActivityEvent } from "../../lib/siem-logging";
import { isAgentInteropSecretValid } from "../../lib/agent-interop";
import { markAlexandriaActivity } from "../../lib/alexandria-activity";
import { DEFAULT_TEAM_LIMITS } from "../../services/autumn/autumn.service";
import { isUsOnly } from "../../lib/us-only";

const AGENT_INTEROP_CONCURRENCY_BOOST = 3;

export async function scrapeController(
  req: RequestWithAuth<{}, ScrapeResponse, ScrapeRequest>,
  res: Response<ScrapeResponse>,
) {
  if (req.body && "alexandria" in req.body)
    return providerScrapeController(req, res);
  // Resolved before the root span starts so the whole request trace stays
  // unrecorded for zero-data-retention requests (see otel-tracer). Safe Mode
  // lockdown implies ZDR, so fold it in here too — otherwise the rejection
  // paths below would export the target URL on the root span.
  const zeroDataRetentionTrace =
    getScrapeZDR(req.acuc?.flags) === "forced" ||
    req.body?.zeroDataRetention === true ||
    req.body?.lockdown === true ||
    isLockdownZeroDataRetention(req.acuc?.flags, req.body?.safeMode);

  return withSpan(
    "api.scrape.request",
    async span => {
      // Get timing data from middleware (includes all middleware processing time)
      const middlewareStartTime =
        (req as any).requestTiming?.startTime || new Date().getTime();
      const controllerStartTime = new Date().getTime();

      const jobId = uuidv7();
      const preNormalizedBody = { ...req.body };

      // Set initial span attributes
      setSpanAttributes(span, {
        "scrape.job_id": jobId,
        "scrape.url": req.body.url,
        "scrape.team_id": req.auth.team_id,
        "scrape.api_key_id": req.acuc?.api_key_id,
        "scrape.middleware_time_ms": controllerStartTime - middlewareStartTime,
      });

      // Validation span
      await withSpan("api.scrape.validate", async validateSpan => {
        req.body = scrapeRequestSchema.parse(req.body);
        setSpanAttributes(validateSpan, {
          "validation.success": true,
        });
      });

      const emitSafeModeRejection = (message: string) =>
        emitRejectedScrapeActivityEvent({
          scrapeId: jobId,
          requestId: jobId,
          endpoint: "scrape",
          teamId: req.auth.team_id,
          apiKeyId: req.acuc?.api_key_id ?? null,
          url: req.body.url,
          error: new TransportableError("SAFE_MODE_BLOCKED", message),
          origin: req.body.origin ?? "api",
          integration: req.body.integration,
          zeroDataRetention: req.body.zeroDataRetention ?? false,
        });

      const safeMode = resolveSafeMode(
        req.acuc?.flags,
        req.body.safeMode,
        req.body.url,
      );
      if (safeMode.error) {
        setSpanAttributes(span, {
          "scrape.error": safeMode.error,
          "scrape.status_code": 403,
        });
        emitSafeModeRejection(safeMode.error);
        return res.status(403).json({
          success: false,
          code: safeMode.code,
          error: safeMode.error,
        });
      }
      setSpanAttributes(span, {
        "scrape.safe_mode": safeMode.safeMode !== undefined,
        "scrape.safe_mode_bypassed": safeMode.bypassed === true,
        "scrape.safe_mode_allowlisted": safeMode.allowlisted === true,
      });

      // Threat protection: resolve the effective policy (org config +
      // per-request override). No-ops (null policy, zero I/O) for teams
      // without the flag.
      const threatProtection = await resolveThreatProtection({
        teamId: req.auth.team_id,
        orgId: req.acuc?.org_id ?? null,
        flags: req.acuc?.flags ?? null,
        override: req.body.threatProtection,
        force: safeMode.safeMode?.domainControls === true,
      });
      if (threatProtection.error) {
        setSpanAttributes(span, {
          "scrape.error": threatProtection.error,
          "scrape.status_code": 403,
        });
        if (safeMode.safeMode?.domainControls) {
          emitSafeModeRejection(threatProtection.error);
        }
        return res.status(403).json({
          success: false,
          error: threatProtection.error,
        });
      }
      // Permission check span
      const permissions = await withSpan(
        "api.scrape.check_permissions",
        async permSpan => {
          const perms = checkPermissions(req.body, req.acuc?.flags, {
            threatProtectionOrgConfig: threatProtection.orgConfig,
            safeMode: safeMode.safeMode ?? null,
          });
          setSpanAttributes(permSpan, {
            "permissions.success": !perms.error,
            "permissions.error": perms.error,
          });
          return perms;
        },
      );

      if (permissions.error) {
        setSpanAttributes(span, {
          "scrape.error": permissions.error,
          "scrape.status_code": 403,
        });
        if (permissions.code === "SAFE_MODE_BLOCKED") {
          emitSafeModeRejection(permissions.error);
        }
        return res.status(403).json({
          success: false,
          code: permissions.code,
          error: permissions.error,
        });
      }

      const keyRestriction = await checkKeyFormatRestriction(
        formatTypesOf(req.body.formats),
        actionTypesOf(req.body.actions),
        req.acuc?.api_key_id,
        req.acuc?.flags ?? null,
      );
      if (!keyRestriction.allowed) {
        setSpanAttributes(span, {
          "scrape.error": keyRestriction.error,
          "scrape.status_code": keyRestriction.status,
        });
        return res.status(keyRestriction.status).json({
          success: false,
          error: keyRestriction.error,
        });
      }

      applySafeMode(safeMode.safeMode, req.body);

      const zeroDataRetention =
        getScrapeZDR(req.acuc?.flags) === "forced" ||
        (req.body.zeroDataRetention ?? false) ||
        (req.body.lockdown ?? false);
      if (req.body.domainTools && zeroDataRetention)
        return res.status(403).json({
          success: false,
          error: "Provider discovery does not support zero data retention.",
        });
      const billing: BillingMetadata = {
        ...(req.body.__agentInterop
          ? { endpoint: "agent" as const, jobId }
          : { endpoint: "scrape" as const, jobId }),
        externalRequestId: externalRequestId(req),
        hostedMcp: req.auth.hostedMcp,
      };

      if (
        req.body.__agentInterop &&
        config.AGENT_INTEROP_SECRET &&
        !isAgentInteropSecretValid(req.body.__agentInterop.auth)
      ) {
        return res.status(403).json({
          success: false,
          error: "Invalid agent interop.",
        });
      } else if (req.body.__agentInterop && !config.AGENT_INTEROP_SECRET) {
        return res.status(403).json({
          success: false,
          error: "Agent interop is not enabled.",
        });
      }

      const shouldBill = req.body.__agentInterop?.shouldBill ?? true;
      const agentRequestId = req.body.__agentInterop?.requestId ?? null;
      const boostConcurrency =
        req.body.__agentInterop?.boostConcurrency ?? false;
      const isDirectToBullMQ = timingSafeSecretEqual(
        req.body.__searchPreviewToken,
        config.SEARCH_PREVIEW_TOKEN,
      );
      const projectedKeylessCredits =
        shouldBill && !isDirectToBullMQ
          ? projectScrapeCredits(
              req.body,
              req.acuc?.flags ?? null,
              zeroDataRetention,
            )
          : 0;
      let reservedKeylessCredits = 0;
      let reconciledKeylessCredits = false;

      if (projectedKeylessCredits > 0) {
        const reservation = await reserveKeylessCredits(
          req.auth.team_id,
          projectedKeylessCredits,
        );
        if (!reservation.ok) {
          applyAgentAuthDiscoveryHeader(res);
          return res
            .status(429)
            .json(await keylessLimitBody(req.auth.team_id, "v2_scrape", req));
        }
        reservedKeylessCredits = projectedKeylessCredits;
      }

      const logger = _logger.child({
        method: "scrapeController",
        jobId,
        noq: true,
        scrapeId: jobId,
        teamId: req.auth.team_id,
        team_id: req.auth.team_id,
        zeroDataRetention,
      });

      const middlewareTime = controllerStartTime - middlewareStartTime;

      if (safeMode.bypassed) {
        logger.info("Safe Mode bypassed by request", {
          apiKeyId: req.acuc?.api_key_id,
        });
      }

      logger.debug("Scrape " + jobId + " starting", {
        version: "v2",
        scrapeId: jobId,
        request: req.body,
        originalRequest: preNormalizedBody,
        account: req.account,
      });

      let logRequestPromise: Promise<any> | undefined = undefined;

      if (!agentRequestId) {
        logRequestPromise = logRequest({
          id: jobId,
          kind: "scrape",
          api_version: "v2",
          external_request_id: externalRequestId(req),
          team_id: req.auth.team_id,
          origin: req.body.origin ?? "api",
          integration: req.body.integration,
          target_hint: req.body.url,
          zeroDataRetention: zeroDataRetention || false,
          api_key_id: req.acuc?.api_key_id ?? null,
        }).catch(err =>
          logger.warn("Background request log failed", { error: err, jobId }),
        );
      }

      setSpanAttributes(span, {
        "scrape.zero_data_retention": zeroDataRetention,
        "scrape.origin": req.body.origin,
        "scrape.timeout": req.body.timeout,
      });

      const origin = req.body.origin;
      const timeout = req.body.timeout;

      const totalWait =
        (req.body.waitFor ?? 0) +
        (req.body.actions ?? []).reduce(
          (a, x) => (x.type === "wait" ? (x.milliseconds ?? 0) : 0) + a,
          0,
        );

      let lockTime: number | null = null;
      let concurrencyLimited: boolean = false;

      let timeoutHandle: NodeJS.Timeout | null = null;
      let doc: Document | null = null;

      try {
        const lockStart = Date.now();
        const aborter = new AbortController();
        if (timeout) {
          // Semaphore has 2/3 of the timeout time to get a lock to allow for scrape time
          timeoutHandle = setTimeout(() => {
            aborter.abort();
          }, timeout * 0.667);
        }
        req.on("close", () => aborter.abort());

        const baseConcurrency =
          req.acuc?.concurrency_limit ?? DEFAULT_TEAM_LIMITS.concurrency_limit;
        const concurrency = boostConcurrency
          ? baseConcurrency * AGENT_INTEROP_CONCURRENCY_BOOST
          : baseConcurrency;

        doc = await teamConcurrencySemaphore.withSemaphore(
          req.auth.team_id,
          jobId,
          concurrency,
          aborter.signal,
          timeout ?? 60_000,
          async limited => {
            const jobPriority = await getJobPriority({
              team_id: req.auth.team_id,
              acuc: req.acuc,
              basePriority: 10,
            });

            lockTime = Date.now() - lockStart;
            concurrencyLimited = limited;

            logger.debug(`Lock acquired for team: ${req.auth.team_id}`, {
              teamId: req.auth.team_id,
              lockTime,
              limited,
            });

            // Wait for job completion span
            const doc = await withSpan(
              "api.scrape.wait_for_job",
              async waitSpan => {
                setSpanAttributes(waitSpan, {
                  "wait.timeout":
                    timeout !== undefined ? timeout + totalWait : undefined,
                  "wait.job_id": jobId,
                });

                const job: NuQJob<ScrapeJobData> = {
                  id: jobId,

                  status: "active",
                  createdAt: new Date(),
                  priority: jobPriority,
                  data: {
                    url: req.body.url,
                    mode: "single_urls",
                    team_id: req.auth.team_id,
                    scrapeOptions: {
                      ...req.body,
                      ...((req.body as any).__experimental_cache
                        ? {
                            maxAge: req.body.maxAge ?? 4 * 60 * 60 * 1000, // 4 hours
                          }
                        : {}),
                    },
                    internalOptions: {
                      teamId: req.auth.team_id,
                      saveScrapeResultToGCS: process.env
                        .GCS_FIRE_ENGINE_BUCKET_NAME
                        ? true
                        : false,
                      unnormalizedSourceURL: preNormalizedBody.url,
                      bypassBilling: isDirectToBullMQ || !shouldBill,
                      zeroDataRetention,
                      teamFlags: req.acuc?.flags ?? null,
                      orgId: req.acuc?.org_id ?? null,
                      teamConcurrency: baseConcurrency,
                      agentIndexOnly: (req as any).agentIndexOnly ?? false,
                      threatProtection: threatProtection.policy ?? undefined,
                      safeMode: safeMode.allowlisted
                        ? undefined
                        : safeMode.safeMode,
                      safeModeBypassed: safeMode.bypassed === true,
                    },
                    skipNuq: true,
                    origin,
                    integration: req.body.integration,
                    billing,
                    startTime: controllerStartTime,
                    zeroDataRetention,
                    apiKeyId: req.acuc?.api_key_id ?? null,
                    concurrencyLimited: limited,
                    keylessReserved: reservedKeylessCredits > 0,
                    requestId: agentRequestId ?? undefined,
                    logRequestPromise: logRequestPromise,
                  },
                };

                const result = await processJobInternal(job);

                setSpanAttributes(waitSpan, {
                  "wait.success": true,
                });

                return result ?? null;
              },
            );

            return doc;
          },
        );
      } catch (e) {
        if (reservedKeylessCredits > 0 && !reconciledKeylessCredits) {
          reconciledKeylessCredits = true;
          adjustKeylessCredits(req.auth.team_id, -reservedKeylessCredits).catch(
            () => {},
          );
        }

        const timeoutErr =
          e instanceof TransportableError &&
          (e.code === "SCRAPE_TIMEOUT" ||
            e.code === "CONCURRENCY_QUEUE_TIMEOUT");

        setSpanAttributes(span, {
          "scrape.error": e instanceof Error ? e.message : String(e),
          "scrape.error_type":
            e instanceof TransportableError ? e.code : "unknown",
        });

        if (e instanceof TransportableError) {
          if (!timeoutErr) {
            logger.error(`Error in scrapeController`, {
              version: "v2",
              error: e,
            });
          }
          // DNS resolution errors should return 200 with success: false
          if (e.code === "SCRAPE_DNS_RESOLUTION_ERROR") {
            setSpanAttributes(span, {
              "scrape.status_code": 200,
            });
            return res.status(200).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "SCRAPE_NO_CACHED_DATA") {
            setSpanAttributes(span, {
              "scrape.status_code": 404,
            });
            return res.status(404).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "SCRAPE_LOCKDOWN_CACHE_MISS") {
            setSpanAttributes(span, {
              "scrape.status_code": 404,
            });
            return res.status(404).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "AGENT_INDEX_ONLY") {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
              sponsor_status: "pending",
              login_url: "https://firecrawl.dev/signin",
            });
          }

          if (e.code === "SCRAPE_ACTIONS_NOT_SUPPORTED") {
            setSpanAttributes(span, {
              "scrape.status_code": 400,
            });
            return res.status(400).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (
            e.code === "unsafe_domain_blocked" ||
            e.code === "US_ONLY_UNAVAILABLE" ||
            e.code === "RESERVED_CAPACITY_UNAVAILABLE"
          ) {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "UNSUPPORTED_SITE") {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "SCRAPE_MEDIA_ACCESS_DENIED") {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "SCRAPE_PROMPT_INJECTION_DETECTED") {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "SCRAPE_JSON_CONTENT_TOO_LARGE") {
            setSpanAttributes(span, {
              "scrape.status_code": 400,
            });
            return res.status(400).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e instanceof ThirdPartyDataTermsRequiredError) {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json(e.response());
          }

          if (
            e.code === "THIRD_PARTY_DATA_NOT_ENABLED" ||
            e.code === "THIRD_PARTY_DATA_ENRICHMENT_NOT_ENABLED"
          ) {
            setSpanAttributes(span, {
              "scrape.status_code": 403,
            });
            return res.status(403).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (e.code === "THIRD_PARTY_DATA_NOT_FOUND") {
            setSpanAttributes(span, {
              "scrape.status_code": 404,
            });
            return res.status(404).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          if (
            e.code === "THIRD_PARTY_DATA_UNSUPPORTED_URL" ||
            e.code === "THIRD_PARTY_DATA_UNSUPPORTED_OPTION"
          ) {
            setSpanAttributes(span, {
              "scrape.status_code": 400,
            });
            return res.status(400).json({
              success: false,
              code: e.code,
              error: e.message,
            });
          }

          const statusCode = timeoutErr ? 408 : 500;
          setSpanAttributes(span, {
            "scrape.status_code": statusCode,
          });
          // Large-PDF timeouts where the fire-pdf job keeps processing
          // server-side carry structured retry guidance: surface it as
          // `details` plus a standard Retry-After header so clients (and
          // retry libraries) know a timed retry returns the finished
          // result instead of restarting the work.
          const processing = getTimeoutProcessingDetails(e);
          if (processing) {
            res.setHeader("Retry-After", String(processing.retryAfterSeconds));
          }
          return res.status(statusCode).json({
            success: false,
            code: e.code,
            error: e.message,
            ...(processing && { details: processing }),
          });
        } else {
          const id = uuidv7();
          logger.error(`Error in scrapeController`, {
            version: "v2",
            error: e,
            errorId: id,
            path: req.path,
            teamId: req.auth.team_id,
          });
          setSpanAttributes(span, {
            "scrape.status_code": 500,
            "scrape.error_id": id,
          });
          return res.status(500).json({
            success: false,
            code: "UNKNOWN_ERROR",
            error: getErrorContactMessage(id),
          });
        }
      } finally {
        if (timeoutHandle) {
          clearTimeout(timeoutHandle);
        }
      }

      if (!hasFormatOfType(req.body.formats, "rawHtml")) {
        if (doc && doc.rawHtml) {
          delete doc.rawHtml;
        }
      }

      if (reservedKeylessCredits > 0 && !reconciledKeylessCredits) {
        reconciledKeylessCredits = true;
        const actualKeylessCredits = doc?.metadata?.creditsUsed ?? 0;
        adjustKeylessCredits(
          req.auth.team_id,
          actualKeylessCredits - reservedKeylessCredits,
        ).catch(() => {});
        logKeylessCreditUsage(req.auth.team_id, actualKeylessCredits).catch(
          () => {},
        );
      }

      const totalRequestTime = new Date().getTime() - middlewareStartTime;
      const controllerTime = new Date().getTime() - controllerStartTime;

      // Set final span attributes
      setSpanAttributes(span, {
        "scrape.success": true,
        "scrape.status_code": 200,
        "scrape.total_request_time_ms": totalRequestTime,
        "scrape.controller_time_ms": controllerTime,
        "scrape.total_wait_time_ms": totalWait,
        "scrape.document.status_code": doc?.metadata?.statusCode,
        "scrape.document.content_type": doc?.metadata?.contentType,
        "scrape.document.error": doc?.metadata?.error,
      });

      let usedLlm =
        !!hasFormatOfType(req.body.formats, "json") ||
        !!hasFormatOfType(req.body.formats, "summary") ||
        !!hasFormatOfType(req.body.formats, "branding") ||
        !!hasFormatOfType(req.body.formats, "question") ||
        !!hasFormatOfType(req.body.formats, "highlights") ||
        !!hasFormatOfType(req.body.formats, "query") ||
        req.body.checkPromptInjection;

      if (!usedLlm) {
        const ct = hasFormatOfType(req.body.formats, "changeTracking");

        if (ct && ct.modes?.includes("json")) {
          usedLlm = true;
        }
      }

      const formats: string[] =
        req.body.formats?.map((f: FormatObject) => f?.type) ?? [];

      logger.info("Request metrics", {
        version: "v2",
        scrapeId: jobId,
        mode: "scrape",
        middlewareStartTime,
        controllerStartTime,
        middlewareTime,
        controllerTime,
        totalRequestTime,
        totalWait,
        usedLlm,
        formats,
        concurrencyLimited,
        concurrencyQueueDurationMs: lockTime || undefined,
      });
      const tools =
        req.body.domainTools && config.FIRE_EXCHANGE_URL
          ? await discoverTools(
              {
                teamId: req.auth.team_id,
                connectors: req.acuc?.flags?.exchangeRetrieve === true,
                usOnly: isUsOnly(req.acuc?.flags),
                toolDetail: req.body.toolDetail,
                urls: [
                  ...new Set(
                    [
                      req.body.url,
                      doc!.metadata?.sourceURL,
                      doc!.metadata?.url,
                    ].filter((u): u is string => typeof u === "string"),
                  ),
                ],
                limit: 24,
                timeoutMs: 10000,
              },
              logger,
            ).catch(error => {
              logger.warn("Domain tool discovery failed", { error });
              return undefined;
            })
          : undefined;
      if (tools) markAlexandriaActivity(req.auth.team_id);
      const toolsWarning = [
        tools?.warning,
        tools?.usOnlyExcluded
          ? usOnlyToolsWarning(tools.usOnlyExcluded)
          : undefined,
      ]
        .filter(Boolean)
        .join(" ");

      return res.status(200).json({
        success: true,
        data: {
          ...doc!,
          metadata: {
            ...doc!.metadata,
            concurrencyLimited,
            concurrencyQueueDurationMs: concurrencyLimited
              ? lockTime || 0
              : undefined,
          },
          ...(tools ? { tools: tools.items } : {}),
        },
        ...(toolsWarning ? { warning: toolsWarning } : {}),
        scrape_id: origin?.includes("website") ? jobId : undefined,
      });
    },
    {
      attributes: {
        "http.method": "POST",
        "http.route": "/v2/scrape",
      },
      kind: SpanKind.SERVER,
      zeroDataRetention: zeroDataRetentionTrace,
    },
  );
}