@astroscope/opentelemetry 0.1.0 → 0.2.0

package/README.md

@@ -74,7 +74,7 @@ Note, since this integration creates spans directly, you don't need to
 // astro.config.ts
 import { defineConfig } from "astro/config";
 import boot from "@astroscope/boot";
-import { opentelemetry } from "@astroscope/opentelemetry";
+import opentelemetry from "@astroscope/opentelemetry";
 
 export default defineConfig({
   integrations: [opentelemetry(), boot()], // opentelemetry() should come as early as possible in the list
@@ -336,10 +336,8 @@ exclude: [
 | `STATIC_EXCLUDES` | Common static files (`/assets/`, `/favicon.ico`, etc.) |
 
 ```ts
-import {
-  opentelemetry,
-  RECOMMENDED_EXCLUDES,
-} from "@astroscope/opentelemetry";
+import opentelemetry from "@astroscope/opentelemetry";
+import { RECOMMENDED_EXCLUDES } from "@astroscope/excludes";
 
 opentelemetry({
   instrumentations: {

package/dist/chunk-45TY3U7U.js

@@ -0,0 +1,77 @@
+import {
+  recordFetchRequestDuration
+} from "./chunk-JU6FJKLT.js";
+
+// src/fetch.ts
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+var LIB_NAME = "@astroscope/opentelemetry";
+function instrumentFetch() {
+  const originalFetch = globalThis.fetch;
+  async function instrumentedFetch(input, init) {
+    const tracer = trace.getTracer(LIB_NAME);
+    const activeContext = context.active();
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const span = tracer.startSpan(
+      `FETCH ${request.method}`,
+      {
+        kind: SpanKind.CLIENT,
+        attributes: {
+          "http.request.method": request.method,
+          "url.full": request.url,
+          "url.path": url.pathname,
+          "url.scheme": url.protocol.replace(":", ""),
+          "server.address": url.hostname,
+          "server.port": url.port ? parseInt(url.port) : url.protocol === "https:" ? 443 : 80
+        }
+      },
+      activeContext
+    );
+    const headers = new Headers(request.headers);
+    const carrier = {};
+    propagation.inject(trace.setSpan(activeContext, span), carrier);
+    for (const [key, value] of Object.entries(carrier)) {
+      headers.set(key, value);
+    }
+    const startTime = performance.now();
+    try {
+      const response = await originalFetch(request.url, {
+        ...init,
+        method: request.method,
+        headers,
+        body: request.body
+      });
+      span.setAttribute("http.response.status_code", response.status);
+      if (response.status >= 400) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: `HTTP ${response.status}`
+        });
+      } else {
+        span.setStatus({ code: SpanStatusCode.OK });
+      }
+      span.end();
+      recordFetchRequestDuration(
+        { method: request.method, host: url.hostname, status: response.status },
+        performance.now() - startTime
+      );
+      return response;
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      span.end();
+      recordFetchRequestDuration(
+        { method: request.method, host: url.hostname, status: 0 },
+        performance.now() - startTime
+      );
+      throw error;
+    }
+  }
+  globalThis.fetch = Object.assign(instrumentedFetch, originalFetch);
+}
+
+export {
+  instrumentFetch
+};

package/dist/chunk-JU6FJKLT.js

@@ -0,0 +1,90 @@
+// src/metrics.ts
+import { ValueType, metrics } from "@opentelemetry/api";
+var LIB_NAME = "@astroscope/opentelemetry";
+var httpRequestDuration = null;
+var httpActiveRequests = null;
+var fetchRequestDuration = null;
+var actionDuration = null;
+function getHttpRequestDuration() {
+  if (!httpRequestDuration) {
+    const meter = metrics.getMeter(LIB_NAME);
+    httpRequestDuration = meter.createHistogram("http.server.request.duration", {
+      description: "Duration of HTTP server requests",
+      unit: "s",
+      valueType: ValueType.DOUBLE
+    });
+  }
+  return httpRequestDuration;
+}
+function getHttpActiveRequests() {
+  if (!httpActiveRequests) {
+    const meter = metrics.getMeter(LIB_NAME);
+    httpActiveRequests = meter.createUpDownCounter("http.server.active_requests", {
+      description: "Number of active HTTP server requests",
+      unit: "{request}",
+      valueType: ValueType.INT
+    });
+  }
+  return httpActiveRequests;
+}
+function getFetchRequestDuration() {
+  if (!fetchRequestDuration) {
+    const meter = metrics.getMeter(LIB_NAME);
+    fetchRequestDuration = meter.createHistogram("http.client.request.duration", {
+      description: "Duration of HTTP client requests (fetch)",
+      unit: "s",
+      valueType: ValueType.DOUBLE
+    });
+  }
+  return fetchRequestDuration;
+}
+function getActionDuration() {
+  if (!actionDuration) {
+    const meter = metrics.getMeter(LIB_NAME);
+    actionDuration = meter.createHistogram("astro.action.duration", {
+      description: "Duration of Astro action executions",
+      unit: "s",
+      valueType: ValueType.DOUBLE
+    });
+  }
+  return actionDuration;
+}
+function recordHttpRequestStart(attributes) {
+  getHttpActiveRequests().add(1, {
+    "http.request.method": attributes.method,
+    "http.route": attributes.route
+  });
+  return () => {
+    getHttpActiveRequests().add(-1, {
+      "http.request.method": attributes.method,
+      "http.route": attributes.route
+    });
+  };
+}
+function recordHttpRequestDuration(attributes, durationMs) {
+  getHttpRequestDuration().record(durationMs / 1e3, {
+    "http.request.method": attributes.method,
+    "http.route": attributes.route,
+    "http.response.status_code": attributes.status
+  });
+}
+function recordFetchRequestDuration(attributes, durationMs) {
+  getFetchRequestDuration().record(durationMs / 1e3, {
+    "http.request.method": attributes.method,
+    "server.address": attributes.host,
+    "http.response.status_code": attributes.status
+  });
+}
+function recordActionDuration(attributes, durationMs) {
+  getActionDuration().record(durationMs / 1e3, {
+    "astro.action.name": attributes.name,
+    "http.response.status_code": attributes.status
+  });
+}
+
+export {
+  recordHttpRequestStart,
+  recordHttpRequestDuration,
+  recordFetchRequestDuration,
+  recordActionDuration
+};

package/dist/chunk-LT23L3YD.js

@@ -0,0 +1,115 @@
+import {
+  recordActionDuration,
+  recordHttpRequestDuration,
+  recordHttpRequestStart
+} from "./chunk-JU6FJKLT.js";
+
+// src/middleware.ts
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { RPCType, setRPCMetadata } from "@opentelemetry/core";
+import { shouldExclude } from "@astroscope/excludes";
+var LIB_NAME = "@astroscope/opentelemetry";
+var ACTIONS_PREFIX = "/_actions/";
+function getClientIp(request) {
+  return request.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? request.headers.get("x-real-ip") ?? request.headers.get("cf-connecting-ip") ?? // no native ip address access in Astro available
+  void 0;
+}
+function createOpenTelemetryMiddleware(options = {}) {
+  const tracer = trace.getTracer(LIB_NAME);
+  return async (ctx, next) => {
+    if (shouldExclude(ctx, options.exclude)) {
+      return next();
+    }
+    const startTime = performance.now();
+    const { request, url } = ctx;
+    const input = { traceparent: request.headers.get("traceparent"), tracestate: request.headers.get("tracestate") };
+    const parentContext = propagation.extract(context.active(), input);
+    const contentLength = request.headers.get("content-length");
+    const clientIp = getClientIp(request);
+    const spanOptions = {
+      attributes: {
+        "http.request.method": request.method,
+        "url.full": request.url,
+        "url.path": url.pathname,
+        "url.query": url.search.slice(1),
+        "url.scheme": url.protocol.replace(":", ""),
+        "server.address": url.hostname,
+        "server.port": url.port ? parseInt(url.port) : url.protocol === "https:" ? 443 : 80,
+        "user_agent.original": request.headers.get("user-agent") ?? "",
+        ...contentLength && { "http.request.body.size": parseInt(contentLength) },
+        ...clientIp && { "client.address": clientIp }
+      },
+      kind: SpanKind.SERVER
+    };
+    const isAction = url.pathname.startsWith(ACTIONS_PREFIX);
+    const actionName = url.pathname.slice(ACTIONS_PREFIX.length).replace(/\/$/, "");
+    const spanName = isAction ? `ACTION ${actionName}` : `${request.method} ${url.pathname}`;
+    const span = tracer.startSpan(spanName, spanOptions, parentContext);
+    const spanContext = trace.setSpan(parentContext, span);
+    const rpcMetadata = { type: RPCType.HTTP, span };
+    const endActiveRequest = recordHttpRequestStart({ method: request.method, route: url.pathname });
+    return context.with(setRPCMetadata(spanContext, rpcMetadata), async () => {
+      const finalize = (status, responseSize) => {
+        span.setAttribute("http.response.status_code", status);
+        span.setAttribute("http.response.body.size", responseSize);
+        if (status >= 400) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: `HTTP ${status}`
+          });
+        } else {
+          span.setStatus({ code: SpanStatusCode.OK });
+        }
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status }, duration);
+        }
+      };
+      try {
+        const response = await next();
+        if (!response.body) {
+          finalize(response.status, 0);
+          return response;
+        }
+        const [measureStream, clientStream] = response.body.tee();
+        let responseSize = 0;
+        (async () => {
+          const reader = measureStream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              responseSize += value.length;
+            }
+          } finally {
+            finalize(response.status, responseSize);
+          }
+        })();
+        return new Response(clientStream, {
+          status: response.status,
+          headers: response.headers
+        });
+      } catch (e) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status: 500 }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status: 500 }, duration);
+        }
+        throw e;
+      }
+    });
+  };
+}
+
+export {
+  createOpenTelemetryMiddleware
+};

package/dist/chunk-PCCKGEEG.js

@@ -0,0 +1,130 @@
+import {
+  recordActionDuration,
+  recordHttpRequestDuration,
+  recordHttpRequestStart
+} from "./chunk-JU6FJKLT.js";
+
+// src/middleware.ts
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { RPCType, setRPCMetadata } from "@opentelemetry/core";
+var LIB_NAME = "@astroscope/opentelemetry";
+var ACTIONS_PREFIX = "/_actions/";
+function matchesPattern(path, pattern) {
+  if ("pattern" in pattern) {
+    return pattern.pattern.test(path);
+  }
+  if ("prefix" in pattern) {
+    return path.startsWith(pattern.prefix);
+  }
+  return path === pattern.exact;
+}
+function shouldExclude(ctx, exclude) {
+  if (!exclude) return false;
+  if (typeof exclude === "function") {
+    return exclude(ctx);
+  }
+  return exclude.some((pattern) => matchesPattern(ctx.url.pathname, pattern));
+}
+function getClientIp(request) {
+  return request.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? request.headers.get("x-real-ip") ?? request.headers.get("cf-connecting-ip") ?? // no native ip address access in Astro available
+  void 0;
+}
+function createOpenTelemetryMiddleware(options = {}) {
+  const tracer = trace.getTracer(LIB_NAME);
+  return async (ctx, next) => {
+    if (shouldExclude(ctx, options.exclude)) {
+      return next();
+    }
+    const startTime = performance.now();
+    const { request, url } = ctx;
+    const input = { traceparent: request.headers.get("traceparent"), tracestate: request.headers.get("tracestate") };
+    const parentContext = propagation.extract(context.active(), input);
+    const contentLength = request.headers.get("content-length");
+    const clientIp = getClientIp(request);
+    const spanOptions = {
+      attributes: {
+        "http.request.method": request.method,
+        "url.full": request.url,
+        "url.path": url.pathname,
+        "url.query": url.search.slice(1),
+        "url.scheme": url.protocol.replace(":", ""),
+        "server.address": url.hostname,
+        "server.port": url.port ? parseInt(url.port) : url.protocol === "https:" ? 443 : 80,
+        "user_agent.original": request.headers.get("user-agent") ?? "",
+        ...contentLength && { "http.request.body.size": parseInt(contentLength) },
+        ...clientIp && { "client.address": clientIp }
+      },
+      kind: SpanKind.SERVER
+    };
+    const isAction = url.pathname.startsWith(ACTIONS_PREFIX);
+    const actionName = url.pathname.slice(ACTIONS_PREFIX.length).replace(/\/$/, "");
+    const spanName = isAction ? `ACTION ${actionName}` : `${request.method} ${url.pathname}`;
+    const span = tracer.startSpan(spanName, spanOptions, parentContext);
+    const spanContext = trace.setSpan(parentContext, span);
+    const rpcMetadata = { type: RPCType.HTTP, span };
+    const endActiveRequest = recordHttpRequestStart({ method: request.method, route: url.pathname });
+    return context.with(setRPCMetadata(spanContext, rpcMetadata), async () => {
+      const finalize = (status, responseSize) => {
+        span.setAttribute("http.response.status_code", status);
+        span.setAttribute("http.response.body.size", responseSize);
+        if (status >= 400) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: `HTTP ${status}`
+          });
+        } else {
+          span.setStatus({ code: SpanStatusCode.OK });
+        }
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status }, duration);
+        }
+      };
+      try {
+        const response = await next();
+        if (!response.body) {
+          finalize(response.status, 0);
+          return response;
+        }
+        const [measureStream, clientStream] = response.body.tee();
+        let responseSize = 0;
+        (async () => {
+          const reader = measureStream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              responseSize += value.length;
+            }
+          } finally {
+            finalize(response.status, responseSize);
+          }
+        })();
+        return new Response(clientStream, {
+          status: response.status,
+          headers: response.headers
+        });
+      } catch (e) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status: 500 }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status: 500 }, duration);
+        }
+        throw e;
+      }
+    });
+  };
+}
+
+export {
+  createOpenTelemetryMiddleware
+};

package/dist/chunk-SNVIK2H6.js

@@ -0,0 +1,115 @@
+import {
+  recordActionDuration,
+  recordHttpRequestDuration,
+  recordHttpRequestStart
+} from "./chunk-JU6FJKLT.js";
+
+// src/middleware.ts
+import { shouldExclude } from "@astroscope/excludes";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { RPCType, setRPCMetadata } from "@opentelemetry/core";
+var LIB_NAME = "@astroscope/opentelemetry";
+var ACTIONS_PREFIX = "/_actions/";
+function getClientIp(request) {
+  return request.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? request.headers.get("x-real-ip") ?? request.headers.get("cf-connecting-ip") ?? // no native ip address access in Astro available
+  void 0;
+}
+function createOpenTelemetryMiddleware(options = {}) {
+  const tracer = trace.getTracer(LIB_NAME);
+  return async (ctx, next) => {
+    if (shouldExclude(ctx, options.exclude)) {
+      return next();
+    }
+    const startTime = performance.now();
+    const { request, url } = ctx;
+    const input = { traceparent: request.headers.get("traceparent"), tracestate: request.headers.get("tracestate") };
+    const parentContext = propagation.extract(context.active(), input);
+    const contentLength = request.headers.get("content-length");
+    const clientIp = getClientIp(request);
+    const spanOptions = {
+      attributes: {
+        "http.request.method": request.method,
+        "url.full": request.url,
+        "url.path": url.pathname,
+        "url.query": url.search.slice(1),
+        "url.scheme": url.protocol.replace(":", ""),
+        "server.address": url.hostname,
+        "server.port": url.port ? parseInt(url.port) : url.protocol === "https:" ? 443 : 80,
+        "user_agent.original": request.headers.get("user-agent") ?? "",
+        ...contentLength && { "http.request.body.size": parseInt(contentLength) },
+        ...clientIp && { "client.address": clientIp }
+      },
+      kind: SpanKind.SERVER
+    };
+    const isAction = url.pathname.startsWith(ACTIONS_PREFIX);
+    const actionName = url.pathname.slice(ACTIONS_PREFIX.length).replace(/\/$/, "");
+    const spanName = isAction ? `ACTION ${actionName}` : `${request.method} ${url.pathname}`;
+    const span = tracer.startSpan(spanName, spanOptions, parentContext);
+    const spanContext = trace.setSpan(parentContext, span);
+    const rpcMetadata = { type: RPCType.HTTP, span };
+    const endActiveRequest = recordHttpRequestStart({ method: request.method, route: url.pathname });
+    return context.with(setRPCMetadata(spanContext, rpcMetadata), async () => {
+      const finalize = (status, responseSize) => {
+        span.setAttribute("http.response.status_code", status);
+        span.setAttribute("http.response.body.size", responseSize);
+        if (status >= 400) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: `HTTP ${status}`
+          });
+        } else {
+          span.setStatus({ code: SpanStatusCode.OK });
+        }
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status }, duration);
+        }
+      };
+      try {
+        const response = await next();
+        if (!response.body) {
+          finalize(response.status, 0);
+          return response;
+        }
+        const [measureStream, clientStream] = response.body.tee();
+        let responseSize = 0;
+        (async () => {
+          const reader = measureStream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              responseSize += value.length;
+            }
+          } finally {
+            finalize(response.status, responseSize);
+          }
+        })();
+        return new Response(clientStream, {
+          status: response.status,
+          headers: response.headers
+        });
+      } catch (e) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        span.end();
+        endActiveRequest();
+        const duration = performance.now() - startTime;
+        recordHttpRequestDuration({ method: request.method, route: url.pathname, status: 500 }, duration);
+        if (isAction) {
+          recordActionDuration({ name: actionName, status: 500 }, duration);
+        }
+        throw e;
+      }
+    });
+  };
+}
+
+export {
+  createOpenTelemetryMiddleware
+};

package/dist/fetch-Z2DBQPE2.js

@@ -0,0 +1,7 @@
+import {
+  instrumentFetch
+} from "./chunk-45TY3U7U.js";
+import "./chunk-JU6FJKLT.js";
+export {
+  instrumentFetch
+};

package/dist/index.d.ts

@@ -1,12 +1,6 @@
 import { APIContext, MiddlewareHandler, AstroIntegration } from 'astro';
+import { ExcludePattern } from '@astroscope/excludes';
 
-type ExcludePattern = {
-    pattern: RegExp;
-} | {
-    prefix: string;
-} | {
-    exact: string;
-};
 interface OpenTelemetryMiddlewareOptions {
     /**
      * Paths to exclude from tracing.
@@ -86,7 +80,7 @@ interface OpenTelemetryIntegrationOptions {
  * ```ts
  * // astro.config.ts
  * import { defineConfig } from "astro/config";
- * import { opentelemetry } from "@astroscope/opentelemetry";
+ * import opentelemetry from "@astroscope/opentelemetry";
  *
  * export default defineConfig({
  *   integrations: [opentelemetry()],
@@ -121,32 +115,4 @@ interface OpenTelemetryIntegrationOptions {
  */
 declare function opentelemetry(options?: OpenTelemetryIntegrationOptions): AstroIntegration;
 
-/**
- * Vite/Astro dev server paths - only relevant in development.
- */
-declare const DEV_EXCLUDES: ExcludePattern[];
-/**
- * Astro internal paths for static assets and image optimization.
- */
-declare const ASTRO_STATIC_EXCLUDES: ExcludePattern[];
-/**
- * Common static asset paths.
- */
-declare const STATIC_EXCLUDES: ExcludePattern[];
-/**
- * Recommended excludes for OpenTelemetry middleware.
- * Includes dev paths, Astro internals, and common static assets.
- *
- * @example
- * ```ts
- * createOpenTelemetryMiddleware({
- *   exclude: [
- *     ...RECOMMENDED_EXCLUDES,
- *     { exact: "/health" }, // your health endpoint
- *   ],
- * })
- * ```
- */
-declare const RECOMMENDED_EXCLUDES: ExcludePattern[];
-
-export { ASTRO_STATIC_EXCLUDES, DEV_EXCLUDES, type ExcludePattern, type OpenTelemetryIntegrationOptions, type OpenTelemetryMiddlewareOptions, RECOMMENDED_EXCLUDES, STATIC_EXCLUDES, createOpenTelemetryMiddleware, instrumentFetch, opentelemetry };
+export { type OpenTelemetryIntegrationOptions, type OpenTelemetryMiddlewareOptions, createOpenTelemetryMiddleware, opentelemetry as default, instrumentFetch };

package/dist/index.js

@@ -1,57 +1,17 @@
 import {
   createOpenTelemetryMiddleware
-} from "./chunk-7RBJ7XB3.js";
+} from "./chunk-SNVIK2H6.js";
 import {
   instrumentFetch
-} from "./chunk-BQFWPPEO.js";
-import "./chunk-DPYEL3WF.js";
+} from "./chunk-45TY3U7U.js";
+import "./chunk-JU6FJKLT.js";
 
 // src/integration.ts
 import fs from "fs";
 import path from "path";
-
-// src/excludes.ts
-var DEV_EXCLUDES = [
-  { prefix: "/@id/" },
-  { prefix: "/@fs/" },
-  { prefix: "/@vite/" },
-  { prefix: "/src/" },
-  { prefix: "/node_modules/" }
-];
-var ASTRO_STATIC_EXCLUDES = [
-  { prefix: "/_astro/" },
-  { prefix: "/_image" }
-];
-var STATIC_EXCLUDES = [
-  { exact: "/favicon.ico" },
-  { exact: "/robots.txt" },
-  { exact: "/sitemap.xml" },
-  { exact: "/browserconfig.xml" },
-  { exact: "/manifest.json" },
-  { exact: "/manifest.webmanifest" },
-  { prefix: "/.well-known/" }
-];
-var RECOMMENDED_EXCLUDES = [
-  ...DEV_EXCLUDES,
-  ...ASTRO_STATIC_EXCLUDES,
-  ...STATIC_EXCLUDES
-];
-
-// src/integration.ts
+import { RECOMMENDED_EXCLUDES, serializeExcludePatterns } from "@astroscope/excludes";
 var VIRTUAL_MODULE_ID = "virtual:@astroscope/opentelemetry/config";
-var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-function serializeExcludePatterns(patterns) {
-  const items = patterns.map((p) => {
-    if ("pattern" in p) {
-      return `{ pattern: ${p.pattern.toString()} }`;
-    } else if ("prefix" in p) {
-      return `{ prefix: ${JSON.stringify(p.prefix)} }`;
-    } else {
-      return `{ exact: ${JSON.stringify(p.exact)} }`;
-    }
-  });
-  return `[${items.join(", ")}]`;
-}
+var RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
 function opentelemetry(options = {}) {
   const httpConfig = options.instrumentations?.http ?? {
     enabled: true,
@@ -64,12 +24,7 @@ function opentelemetry(options = {}) {
   return {
     name: "@astroscope/opentelemetry",
     hooks: {
-      "astro:config:setup": ({
-        command,
-        updateConfig,
-        logger,
-        addMiddleware
-      }) => {
+      "astro:config:setup": ({ command, updateConfig, logger, addMiddleware }) => {
         isBuild = command === "build";
         if (httpConfig.enabled) {
           addMiddleware({
@@ -93,7 +48,6 @@ function opentelemetry(options = {}) {
                   }
                 }
               },
-              // Only add fetch instrumentation plugin if enabled
               ...fetchConfig.enabled ? [
                 {
                   name: "@astroscope/opentelemetry/fetch",
@@ -101,7 +55,7 @@ function opentelemetry(options = {}) {
                     if (isBuild) return;
                     server.httpServer?.once("listening", async () => {
                       try {
-                        const { instrumentFetch: instrumentFetch2 } = await import("./fetch-RERXGIJA.js");
+                        const { instrumentFetch: instrumentFetch2 } = await import("./fetch-Z2DBQPE2.js");
                         instrumentFetch2();
                         logger.info("fetch instrumentation enabled");
                       } catch (error) {
@@ -118,15 +72,14 @@ function opentelemetry(options = {}) {
                     if (!outDir) return;
                     const entryPath = path.join(outDir, "entry.mjs");
                     if (!fs.existsSync(entryPath)) return;
-                    let content = fs.readFileSync(entryPath, "utf-8");
-                    const instrumentCode = `import { instrumentFetch } from '@astroscope/opentelemetry';
+                    const content = fs.readFileSync(entryPath, "utf-8");
+                    fs.writeFileSync(
+                      entryPath,
+                      `import { instrumentFetch } from '@astroscope/opentelemetry';
 instrumentFetch();
-`;
-                    content = instrumentCode + content;
-                    fs.writeFileSync(entryPath, content);
-                    logger.info(
-                      "injected fetch instrumentation into entry.mjs"
+${content}`
                     );
+                    logger.info("injected fetch instrumentation into entry.mjs");
                   }
                 }
               ] : []
@@ -138,11 +91,7 @@ instrumentFetch();
   };
 }
 export {
-  ASTRO_STATIC_EXCLUDES,
-  DEV_EXCLUDES,
-  RECOMMENDED_EXCLUDES,
-  STATIC_EXCLUDES,
   createOpenTelemetryMiddleware,
-  instrumentFetch,
-  opentelemetry
+  opentelemetry as default,
+  instrumentFetch
 };

package/dist/middleware-entrypoint.js

@@ -1,13 +1,11 @@
 import {
   createOpenTelemetryMiddleware
-} from "./chunk-7RBJ7XB3.js";
-import "./chunk-DPYEL3WF.js";
+} from "./chunk-SNVIK2H6.js";
+import "./chunk-JU6FJKLT.js";
 
 // src/middleware-entrypoint.ts
 import { excludePatterns } from "virtual:@astroscope/opentelemetry/config";
-var onRequest = createOpenTelemetryMiddleware({
-  exclude: excludePatterns
-});
+var onRequest = createOpenTelemetryMiddleware({ exclude: excludePatterns });
 export {
   onRequest
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astroscope/opentelemetry",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenTelemetry tracing middleware for Astro SSR",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,14 +55,15 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/core": "^1.30.0",
+    "@opentelemetry/core": "^2.2.0",
     "astro": "^5.1.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
+    "@astroscope/excludes": "workspace:*",
     "@opentelemetry/api": "^1.0.0",
-    "@opentelemetry/core": "^1.0.0",
+    "@opentelemetry/core": "^2.0.0",
     "astro": "^5.0.0"
   }
 }