@autter/runtime-next 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# @autter/runtime-next
+
+One-command Autter Runtime for Next.js: server OTel, browser tracker,
+same-origin relay route, and a React error boundary.
+
+## Install
+
+```bash
+npm install @autter/runtime-next
+```
+
+Set `AUTTER_RUNTIME_KEY` in your environment. Then three small files:
+
+**1. `instrumentation.ts`** — server tracing/errors:
+
+```ts
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    const { registerAutter } = await import("@autter/runtime-next");
+    registerAutter({
+      apiKey: process.env.AUTTER_RUNTIME_KEY!,
+      service: "web-app",
+      environment: process.env.NODE_ENV,
+      release: process.env.GIT_SHA,
+    });
+  }
+}
+```
+
+**2. `app/api/autter-runtime/route.ts`** — browser relay (key stays server-side):
+
+```ts
+import { createAutterRelayRoute } from "@autter/runtime-next";
+
+export const { POST } = createAutterRelayRoute({
+  apiKey: process.env.AUTTER_RUNTIME_KEY!,
+});
+```
+
+**3. A client component** — browser tracker + render-error boundary:
+
+```tsx
+"use client";
+import { initAutterBrowser, AutterErrorBoundary } from "@autter/runtime-next";
+
+initAutterBrowser({
+  endpoint: "/api/autter-runtime",
+  service: "web-app",
+  release: process.env.NEXT_PUBLIC_GIT_SHA,
+});
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <AutterErrorBoundary fallback={<p>Something went wrong.</p>}>
+      {children}
+    </AutterErrorBoundary>
+  );
+}
+```
+
+React render errors don't reach `window.onerror` — the boundary reports
+them via `captureException` and then renders your fallback.
+
+Also re-exported for convenience: `captureException`, `captureMessage`,
+`trackEvent`, `setUser`, `setContext`, `flush` (browser) and
+`captureServerException`, `captureServerMessage` (server).

package/dist/index.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AutterErrorBoundary: () => AutterErrorBoundary,
+  captureException: () => import_runtime_browser2.captureException,
+  captureMessage: () => import_runtime_browser2.captureMessage,
+  captureServerException: () => import_runtime_node2.captureException,
+  captureServerMessage: () => import_runtime_node2.captureMessage,
+  createAutterRelayRoute: () => createAutterRelayRoute,
+  flush: () => import_runtime_browser2.flush,
+  initAutterBrowser: () => import_runtime_browser2.initAutterBrowser,
+  registerAutter: () => registerAutter,
+  setContext: () => import_runtime_browser2.setContext,
+  setUser: () => import_runtime_browser2.setUser,
+  trackEvent: () => import_runtime_browser2.trackEvent
+});
+module.exports = __toCommonJS(index_exports);
+var import_runtime_node = require("@autter/runtime-node");
+var import_runtime_browser2 = require("@autter/runtime-browser");
+
+// src/error-boundary.ts
+var React = __toESM(require("react"), 1);
+var import_runtime_browser = require("@autter/runtime-browser");
+var AutterErrorBoundary = class extends React.Component {
+  state = { hasError: false };
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error, info) {
+    (0, import_runtime_browser.captureException)(error, {
+      react: true,
+      ...info.componentStack ? { componentStack: String(info.componentStack).slice(0, 4e3) } : {}
+    });
+    this.props.onError?.(error, info);
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+
+// src/index.ts
+var import_runtime_node2 = require("@autter/runtime-node");
+function registerAutter(options) {
+  return (0, import_runtime_node.initAutterServer)(options);
+}
+function createAutterRelayRoute(options) {
+  return { POST: (0, import_runtime_node.createBrowserRelayFetchHandler)(options) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutterErrorBoundary,
+  captureException,
+  captureMessage,
+  captureServerException,
+  captureServerMessage,
+  createAutterRelayRoute,
+  flush,
+  initAutterBrowser,
+  registerAutter,
+  setContext,
+  setUser,
+  trackEvent
+});

package/dist/index.d.cts

@@ -0,0 +1,68 @@
+import { RelayOptions, AutterServerOptions, AutterServer } from '@autter/runtime-node';
+export { captureException as captureServerException, captureMessage as captureServerMessage } from '@autter/runtime-node';
+export { AutterSeverity, captureException, captureMessage, flush, initAutterBrowser, setContext, setUser, trackEvent } from '@autter/runtime-browser';
+import * as React from 'react';
+
+/**
+ * React error boundary that reports render errors to Autter Runtime.
+ * React rendering errors do NOT hit `window.onerror`, so the browser
+ * tracker alone misses them — wrap your app:
+ *
+ *   <AutterErrorBoundary fallback={<ErrorPage />}>
+ *     <Application />
+ *   </AutterErrorBoundary>
+ */
+interface AutterErrorBoundaryProps {
+    fallback?: React.ReactNode;
+    /** Called after the error is reported (e.g. to show a toast). */
+    onError?: (error: Error, info: React.ErrorInfo) => void;
+    children?: React.ReactNode;
+}
+interface State {
+    hasError: boolean;
+}
+declare class AutterErrorBoundary extends React.Component<AutterErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(): State;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+
+/**
+ * @autter/runtime-next — one-command Autter Runtime for Next.js.
+ *
+ * 1. `instrumentation.ts` (server tracing):
+ *
+ *      export async function register() {
+ *        if (process.env.NEXT_RUNTIME === "nodejs") {
+ *          const { registerAutter } = await import("@autter/runtime-next");
+ *          registerAutter({
+ *            apiKey: process.env.AUTTER_RUNTIME_KEY!,
+ *            service: "web-app",
+ *            release: process.env.GIT_SHA,
+ *          });
+ *        }
+ *      }
+ *
+ * 2. `app/api/autter-runtime/route.ts` (browser relay):
+ *
+ *      import { createAutterRelayRoute } from "@autter/runtime-next";
+ *      export const { POST } = createAutterRelayRoute({
+ *        apiKey: process.env.AUTTER_RUNTIME_KEY!,
+ *      });
+ *
+ * 3. A client component (browser tracker + boundary):
+ *
+ *      "use client";
+ *      import { initAutterBrowser, AutterErrorBoundary } from "@autter/runtime-next";
+ *      initAutterBrowser({ endpoint: "/api/autter-runtime", service: "web-app" });
+ */
+
+/** Server OTel init for Next.js `instrumentation.ts`. */
+declare function registerAutter(options: AutterServerOptions): AutterServer;
+/** App Router relay route: `export const { POST } = createAutterRelayRoute({...})`. */
+declare function createAutterRelayRoute(options: RelayOptions): {
+    POST: (request: Request) => Promise<Response>;
+};
+
+export { AutterErrorBoundary, type AutterErrorBoundaryProps, createAutterRelayRoute, registerAutter };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { RelayOptions, AutterServerOptions, AutterServer } from '@autter/runtime-node';
+export { captureException as captureServerException, captureMessage as captureServerMessage } from '@autter/runtime-node';
+export { AutterSeverity, captureException, captureMessage, flush, initAutterBrowser, setContext, setUser, trackEvent } from '@autter/runtime-browser';
+import * as React from 'react';
+
+/**
+ * React error boundary that reports render errors to Autter Runtime.
+ * React rendering errors do NOT hit `window.onerror`, so the browser
+ * tracker alone misses them — wrap your app:
+ *
+ *   <AutterErrorBoundary fallback={<ErrorPage />}>
+ *     <Application />
+ *   </AutterErrorBoundary>
+ */
+interface AutterErrorBoundaryProps {
+    fallback?: React.ReactNode;
+    /** Called after the error is reported (e.g. to show a toast). */
+    onError?: (error: Error, info: React.ErrorInfo) => void;
+    children?: React.ReactNode;
+}
+interface State {
+    hasError: boolean;
+}
+declare class AutterErrorBoundary extends React.Component<AutterErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(): State;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+
+/**
+ * @autter/runtime-next — one-command Autter Runtime for Next.js.
+ *
+ * 1. `instrumentation.ts` (server tracing):
+ *
+ *      export async function register() {
+ *        if (process.env.NEXT_RUNTIME === "nodejs") {
+ *          const { registerAutter } = await import("@autter/runtime-next");
+ *          registerAutter({
+ *            apiKey: process.env.AUTTER_RUNTIME_KEY!,
+ *            service: "web-app",
+ *            release: process.env.GIT_SHA,
+ *          });
+ *        }
+ *      }
+ *
+ * 2. `app/api/autter-runtime/route.ts` (browser relay):
+ *
+ *      import { createAutterRelayRoute } from "@autter/runtime-next";
+ *      export const { POST } = createAutterRelayRoute({
+ *        apiKey: process.env.AUTTER_RUNTIME_KEY!,
+ *      });
+ *
+ * 3. A client component (browser tracker + boundary):
+ *
+ *      "use client";
+ *      import { initAutterBrowser, AutterErrorBoundary } from "@autter/runtime-next";
+ *      initAutterBrowser({ endpoint: "/api/autter-runtime", service: "web-app" });
+ */
+
+/** Server OTel init for Next.js `instrumentation.ts`. */
+declare function registerAutter(options: AutterServerOptions): AutterServer;
+/** App Router relay route: `export const { POST } = createAutterRelayRoute({...})`. */
+declare function createAutterRelayRoute(options: RelayOptions): {
+    POST: (request: Request) => Promise<Response>;
+};
+
+export { AutterErrorBoundary, type AutterErrorBoundaryProps, createAutterRelayRoute, registerAutter };

package/dist/index.js

@@ -0,0 +1,63 @@
+// src/index.ts
+import {
+  createBrowserRelayFetchHandler,
+  initAutterServer
+} from "@autter/runtime-node";
+import {
+  initAutterBrowser,
+  captureException as captureException2,
+  captureMessage,
+  trackEvent,
+  setUser,
+  setContext,
+  flush
+} from "@autter/runtime-browser";
+
+// src/error-boundary.ts
+import * as React from "react";
+import { captureException } from "@autter/runtime-browser";
+var AutterErrorBoundary = class extends React.Component {
+  state = { hasError: false };
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error, info) {
+    captureException(error, {
+      react: true,
+      ...info.componentStack ? { componentStack: String(info.componentStack).slice(0, 4e3) } : {}
+    });
+    this.props.onError?.(error, info);
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+
+// src/index.ts
+import {
+  captureException as captureException3,
+  captureMessage as captureMessage2
+} from "@autter/runtime-node";
+function registerAutter(options) {
+  return initAutterServer(options);
+}
+function createAutterRelayRoute(options) {
+  return { POST: createBrowserRelayFetchHandler(options) };
+}
+export {
+  AutterErrorBoundary,
+  captureException2 as captureException,
+  captureMessage,
+  captureException3 as captureServerException,
+  captureMessage2 as captureServerMessage,
+  createAutterRelayRoute,
+  flush,
+  initAutterBrowser,
+  registerAutter,
+  setContext,
+  setUser,
+  trackEvent
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@autter/runtime-next",
+	"version": "0.1.0",
+	"description": "One-command Autter Runtime for Next.js: server OTel, browser tracker, relay route, and React error boundary",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Autter-dev/autter-runtime.git",
+		"directory": "packages/runtime-next"
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format esm,cjs --dts --target node20 --external react --clean"
+	},
+	"dependencies": {
+		"@autter/runtime-browser": "0.1.0",
+		"@autter/runtime-node": "0.1.0"
+	},
+	"peerDependencies": {
+		"react": ">=18"
+	},
+	"devDependencies": {
+		"@types/react": "^18.3.0",
+		"tsup": "^8.3.5",
+		"typescript": "^5.7.0"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"homepage": "https://github.com/Autter-dev/autter-runtime#readme",
+	"bugs": "https://github.com/Autter-dev/autter-runtime/issues",
+	"keywords": [
+		"nextjs",
+		"error-tracking",
+		"telemetry",
+		"opentelemetry",
+		"react",
+		"error-boundary"
+	]
+}