miniflare 0.0.0-e7ea6005c → 0.0.0-e8aaa3930

package/dist/src/workers/assets/assets.worker.js

@@ -8622,6 +8622,17 @@ var require_index_cjs = __commonJS({
 // ../workers-shared/asset-worker/src/index.ts
 import { WorkerEntrypoint } from "cloudflare:workers";
 
+// ../workers-shared/utils/performance.ts
+var PerformanceTimer = class {
+  performanceTimer;
+  constructor(performanceTimer) {
+    this.performanceTimer = performanceTimer;
+  }
+  now() {
+    return this.performanceTimer ? this.performanceTimer.timeOrigin + this.performanceTimer.now() : Date.now();
+  }
+};
+
 // ../workers-shared/utils/sentry.ts
 var import_toucan_js = __toESM(require_index_cjs());
 function setupSentry(request, context, dsn, clientId, clientSecret) {
@@ -8657,6 +8668,55 @@ function setupSentry(request, context, dsn, clientId, clientSecret) {
   return sentry.setUser({ userAgent, colo }), sentry;
 }
 
+// ../workers-shared/asset-worker/src/analytics.ts
+var Analytics = class {
+  data = {};
+  readyAnalytics;
+  constructor(readyAnalytics) {
+    this.readyAnalytics = readyAnalytics;
+  }
+  setData(newData) {
+    this.data = { ...this.data, ...newData };
+  }
+  getData(key) {
+    return this.data[key];
+  }
+  write() {
+    this.readyAnalytics && this.readyAnalytics.logEvent({
+      version: 1,
+      accountId: 0,
+      // TODO: need to plumb through
+      indexId: this.data.hostname?.substring(0, 96),
+      doubles: [
+        this.data.requestTime ?? -1,
+        // double1
+        this.data.coloId ?? -1,
+        // double2
+        this.data.metalId ?? -1,
+        // double3
+        this.data.coloTier ?? -1
+        // double4
+      ],
+      blobs: [
+        this.data.hostname?.substring(0, 256),
+        // blob1 - trim to 256 bytes
+        this.data.userAgent?.substring(0, 256),
+        // blob2 - trim to 256 bytes
+        this.data.htmlHandling,
+        // blob3
+        this.data.notFoundHandling,
+        // blob4
+        this.data.error?.substring(0, 256),
+        // blob5 - trim to 256 bytes
+        this.data.version,
+        // blob6
+        this.data.coloRegion
+        // blob7
+      ]
+    });
+  }
+};
+
 // ../workers-shared/asset-worker/src/assets-manifest.ts
 var AssetsManifest = class {
   data;
@@ -8716,7 +8776,8 @@ var AssetsManifest = class {
 // ../workers-shared/asset-worker/src/configuration.ts
 var applyConfigurationDefaults = (configuration) => ({
   html_handling: configuration?.html_handling ?? "auto-trailing-slash",
-  not_found_handling: configuration?.not_found_handling ?? "none"
+  not_found_handling: configuration?.not_found_handling ?? "none",
+  serve_directly: configuration?.serve_directly ?? !0
 });
 
 // ../workers-shared/asset-worker/src/responses.ts
@@ -8788,19 +8849,25 @@ function isCacheable(request) {
 }
 
 // ../workers-shared/asset-worker/src/handler.ts
-var handleRequest = async (request, configuration, exists, getByETag) => {
-  let { pathname, search } = new URL(request.url), decodedPathname = decodePath(pathname), intent = await getIntent(decodedPathname, configuration, exists);
+var handleRequest = async (request, env, configuration, exists, getByETag) => {
+  let { pathname, search } = new URL(request.url), decodedPathname = decodePath(pathname);
+  decodedPathname = decodedPathname.replace(/\/+/g, "/");
+  let intent = await getIntent(decodedPathname, configuration, exists);
   if (!intent)
     return new NotFoundResponse();
   let method = request.method.toUpperCase();
   if (!["GET", "HEAD"].includes(method))
     return new MethodNotAllowedResponse();
   let decodedDestination = intent.redirect ?? decodedPathname, encodedDestination = encodePath(decodedDestination);
-  if (encodedDestination !== pathname || intent.redirect)
+  if (encodedDestination !== pathname && intent.asset || intent.redirect)
     return new TemporaryRedirectResponse(encodedDestination + search);
   if (!intent.asset)
     return new InternalServerErrorResponse(new Error("Unknown action"));
-  let asset = await getByETag(intent.asset.eTag), headers = getHeaders(intent.asset.eTag, asset.contentType, request), strongETag = `"${intent.asset.eTag}"`, weakETag = `W/${strongETag}`, ifNoneMatch = request.headers.get("If-None-Match") || "";
+  let asset = await env.JAEGER.enterSpan("getByETag", async (span) => (span.setTags({
+    pathname,
+    eTag: intent.asset.eTag,
+    status: intent.asset.status
+  }), await getByETag(intent.asset.eTag))), headers = getHeaders(intent.asset.eTag, asset.contentType, request), strongETag = `"${intent.asset.eTag}"`, weakETag = `W/${strongETag}`, ifNoneMatch = request.headers.get("If-None-Match") || "";
   if ([weakETag, strongETag].includes(ifNoneMatch))
     return new NotModifiedResponse(null, { headers });
   let body = method === "HEAD" ? null : asset.readableStream;
@@ -9178,18 +9245,46 @@ var handleRequest = async (request, configuration, exists, getByETag) => {
       };
   }
   return null;
-}, decodePath = (pathname) => pathname.split("/").map((x) => decodeURIComponent(x)).join("/"), encodePath = (pathname) => pathname.split("/").map((x) => encodeURIComponent(x)).join("/");
+}, decodePath = (pathname) => pathname.split("/").map((x) => {
+  try {
+    return decodeURIComponent(x);
+  } catch {
+    return x;
+  }
+}).join("/"), encodePath = (pathname) => pathname.split("/").map((x) => {
+  try {
+    return encodeURIComponent(x);
+  } catch {
+    return x;
+  }
+}).join("/");
 
 // ../workers-shared/asset-worker/src/utils/kv.ts
-async function getAssetWithMetadataFromKV(assetsKVNamespace, assetKey, retries = 1) {
+async function getAssetWithMetadataFromKV(assetsKVNamespace, assetKey, sentry, retries = 1) {
   let attempts = 0;
   for (; attempts <= retries; )
     try {
-      return await assetsKVNamespace.getWithMetadata(assetKey, {
-        type: "stream",
-        cacheTtl: 31536e3
-        // 1 year
-      });
+      let asset = await assetsKVNamespace.getWithMetadata(
+        assetKey,
+        {
+          type: "stream",
+          cacheTtl: 31536e3
+          // 1 year
+        }
+      );
+      if (asset.value === null) {
+        let retriedAsset = await assetsKVNamespace.getWithMetadata(assetKey, {
+          type: "stream",
+          cacheTtl: 60
+          // Minimum value allowed
+        });
+        return retriedAsset.value !== null && sentry && sentry.captureException(
+          new Error(
+            `Initial request for asset ${assetKey} failed, but subsequent request succeeded.`
+          )
+        ), retriedAsset;
+      }
+      return asset;
     } catch {
       if (attempts >= retries)
         throw new Error(
@@ -9201,38 +9296,98 @@ async function getAssetWithMetadataFromKV(assetsKVNamespace, assetKey, retries =
     }
 }
 
+// ../workers-shared/asset-worker/src/utils/mocks.ts
+function mockJaegerBindingSpan() {
+  return {
+    addLogs: () => {
+    },
+    setTags: () => {
+    },
+    end: () => {
+    },
+    isRecording: !0
+  };
+}
+function mockJaegerBinding() {
+  return {
+    enterSpan: (_, span, ...args) => span(mockJaegerBindingSpan(), ...args),
+    getSpanContext: () => ({
+      traceId: "test-trace",
+      spanId: "test-span",
+      parentSpanId: "test-parent-span",
+      traceFlags: 0
+    }),
+    runWithSpanContext: (_, callback, ...args) => callback(...args),
+    traceId: "test-trace",
+    spanId: "test-span",
+    parentSpanId: "test-parent-span",
+    cfTraceIdHeader: "test-trace:test-span:0"
+  };
+}
+
 // ../workers-shared/asset-worker/src/index.ts
 var src_default = class extends WorkerEntrypoint {
   async fetch(request) {
-    let sentry;
+    let sentry, analytics = new Analytics(this.env.ANALYTICS), performance = new PerformanceTimer(this.env.UNSAFE_PERFORMANCE), startTimeMs = performance.now();
     try {
-      return sentry = setupSentry(
+      this.env.JAEGER || (this.env.JAEGER = mockJaegerBinding()), sentry = setupSentry(
         request,
         this.ctx,
         this.env.SENTRY_DSN,
         this.env.SENTRY_ACCESS_CLIENT_ID,
         this.env.SENTRY_ACCESS_CLIENT_SECRET
-      ), handleRequest(
+      );
+      let config = applyConfigurationDefaults(this.env.CONFIG), userAgent = request.headers.get("user-agent") ?? "UA UNKNOWN";
+      if (sentry) {
+        let colo = this.env.COLO_METADATA.coloId;
+        sentry.setTag("colo", this.env.COLO_METADATA.coloId), sentry.setTag("metal", this.env.COLO_METADATA.metalId), sentry.setUser({ userAgent, colo });
+      }
+      let url = new URL(request.url);
+      return this.env.COLO_METADATA && this.env.VERSION_METADATA && analytics.setData({
+        coloId: this.env.COLO_METADATA.coloId,
+        metalId: this.env.COLO_METADATA.metalId,
+        coloTier: this.env.COLO_METADATA.coloTier,
+        coloRegion: this.env.COLO_METADATA.coloRegion,
+        version: this.env.VERSION_METADATA.id,
+        hostname: url.hostname,
+        htmlHandling: config.html_handling,
+        notFoundHandling: config.not_found_handling,
+        userAgent
+      }), this.env.JAEGER.enterSpan("handleRequest", async (span) => (span.setTags({
+        hostname: url.hostname,
+        eyeballPath: url.pathname,
+        env: this.env.ENVIRONMENT
+      }), handleRequest(
         request,
-        applyConfigurationDefaults(this.env.CONFIG),
+        this.env,
+        config,
         this.unstable_exists.bind(this),
         this.unstable_getByETag.bind(this)
+      ))).catch(
+        (err) => this.handleError(sentry, analytics, performance, startTimeMs, err)
       );
     } catch (err) {
+      return this.handleError(sentry, analytics, performance, startTimeMs, err);
+    }
+  }
+  handleError(sentry, analytics, performance, startTimeMs, err) {
+    try {
       let response = new InternalServerErrorResponse(err);
-      return sentry && sentry.captureException(err), response;
+      return sentry && sentry.captureException(err), err instanceof Error && analytics.setData({ error: err.message }), response;
+    } finally {
+      analytics.setData({ requestTime: performance.now() - startTimeMs }), analytics.write();
     }
   }
   async unstable_canFetch(request) {
-    let url = new URL(request.url), method = request.method.toUpperCase(), decodedPathname = decodePath(url.pathname), intent = await getIntent(
+    let url = new URL(request.url), decodedPathname = decodePath(url.pathname);
+    return await getIntent(
       decodedPathname,
       {
         ...applyConfigurationDefaults(this.env.CONFIG),
         not_found_handling: "none"
       },
       this.unstable_exists.bind(this)
-    );
-    return intent && ["GET", "HEAD"].includes(method) ? new MethodNotAllowedResponse() : intent !== null;
+    ) !== null;
   }
   async unstable_getByETag(eTag) {
     let asset = await getAssetWithMetadataFromKV(