@allstak/angular 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to `@allstak/angular` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] — 2026-05-29
+
+Initial release of the official AllStak SDK for Angular.
+
+### Added
+
+- `init(config)` — thin bootstrap over `@allstak/js` that stamps the wrapper
+  identity (`sdkName: 'allstak-angular'`, `sdkVersion`) so backend ingest can
+  distinguish Angular traffic. The SDK version is generated at build time from
+  `package.json`, never hand-written.
+- `createErrorHandler(options?)` / `AllStakErrorHandler` — an Angular
+  `ErrorHandler` that forwards uncaught errors to `AllStak.captureException`.
+  Unwraps the common Angular/zone.js envelopes (`ngOriginalError`, promise
+  `rejection`, `HttpErrorResponse.error`, `ErrorEvent.error`), coerces
+  non-`Error` throws, and supports a custom `extractor` plus a `logErrors`
+  toggle.
+- `AllStakHttpInterceptor` (class) and `allStakHttpInterceptor` (functional) —
+  an `HttpInterceptor` that records every outbound request as an `outbound`
+  HTTP item and opens a `http.client` span around it, finishing `error` on
+  `4xx`/`5xx` responses or transport failures. Never mutates the request.
+- `TraceService` — injectable, Router-aware navigation instrumentation that
+  opens a `navigation` span per route change (`ok` on `NavigationEnd`, `error`
+  on `NavigationCancel` / `NavigationError`) and records a navigation
+  breadcrumb. `@angular/router` is an optional peer, so the service degrades to
+  a no-op when no `Router` is present.
+- `TraceDirective` (`[trace]`) and `AllStakTraceModule` — component
+  render-timing directive that opens a `ui.angular.init` span between
+  `ngOnInit` and `ngAfterViewInit`.
+- `TraceClassDecorator` / `TraceClass` and `TraceMethodDecorator` /
+  `TraceMethod` — class- and method-level lifecycle span decorators with a
+  required `name` so spans survive minification.
+- Provider functions for standalone apps: `provideAllStak(config)`,
+  `provideAllStakErrorHandler(options?)`, and
+  `provideAllStakRouterInstrumentation()` (which force-instantiates
+  `TraceService` via `APP_INITIALIZER`).
+- `AllStakModule.forRoot(config)` for module-based apps — initialises the SDK,
+  overrides the global `ErrorHandler`, force-instantiates `TraceService`, and
+  exposes the `[trace]` directive.
+- Full re-export of the `@allstak/js` public surface so consumers can pull the
+  entire observability API from a single namespaced import.
+- Built with ng-packagr (Angular Package Format): FESM2022 bundles, `esm2022`
+  output, and partial-Ivy type declarations across the `@angular` 14–18 peer
+  range.
+
+[0.1.0]: https://github.com/AllStak/allstak-angular/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AllStak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,186 @@
+# @allstak/angular
+
+[![npm](https://img.shields.io/npm/v/@allstak/angular.svg)](https://www.npmjs.com/package/@allstak/angular)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Official AllStak SDK for **Angular**. Captures uncaught exceptions, structured logs, navigation spans, outbound HTTP requests, and component render timing — with first-class support for both standalone and NgModule-based apps.
+
+## Install
+
+```bash
+npm install @allstak/angular
+# or
+pnpm add @allstak/angular
+# or
+yarn add @allstak/angular
+```
+
+`@angular/core`, `@angular/common`, and `rxjs` are peer dependencies; `@angular/router` is an optional peer (only needed for navigation instrumentation).
+
+## Setup
+
+Initialise the SDK once in `main.ts`, **before** you bootstrap the app, so the global error handler and router instrumentation see a live client:
+
+```ts
+import { init } from '@allstak/angular';
+import { bootstrapApplication } from '@angular/platform-browser';
+import { AppComponent } from './app/app.component';
+import { appConfig } from './app/app.config';
+
+init({
+  apiKey: 'your-ingest-key',
+  environment: 'production',
+});
+
+bootstrapApplication(AppComponent, appConfig);
+```
+
+## Standalone apps (provider functions)
+
+Wire the DI pieces in `app.config.ts`:
+
+```ts
+import { ApplicationConfig } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+import {
+  provideAllStak,
+  provideAllStakErrorHandler,
+  provideAllStakRouterInstrumentation,
+  allStakHttpInterceptor,
+} from '@allstak/angular';
+import { routes } from './app.routes';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideRouter(routes),
+
+    // Bootstrap the SDK from DI (alternative to calling init() in main.ts).
+    provideAllStak({ apiKey: 'your-ingest-key', environment: 'production' }),
+
+    // Override Angular's global ErrorHandler — every uncaught error becomes an Issue.
+    provideAllStakErrorHandler(),
+
+    // Open a navigation span per route change.
+    provideAllStakRouterInstrumentation(),
+
+    // Record every outbound HTTP request + open a http.client span.
+    provideHttpClient(withInterceptors([allStakHttpInterceptor])),
+  ],
+};
+```
+
+## NgModule apps
+
+```ts
+import { NgModule, ErrorHandler } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+import { AllStakModule, AllStakHttpInterceptor } from '@allstak/angular';
+import { AppComponent } from './app.component';
+
+@NgModule({
+  declarations: [AppComponent],
+  imports: [
+    BrowserModule,
+
+    // forRoot() initialises the SDK, overrides ErrorHandler, force-instantiates
+    // the router TraceService, and exposes the [trace] directive.
+    AllStakModule.forRoot({ apiKey: 'your-ingest-key', environment: 'production' }),
+  ],
+  providers: [
+    provideHttpClient(withInterceptorsFromDi()),
+    { provide: HTTP_INTERCEPTORS, useClass: AllStakHttpInterceptor, multi: true },
+  ],
+  bootstrap: [AppComponent],
+})
+export class AppModule {}
+```
+
+## Error handling
+
+`createErrorHandler()` returns an Angular `ErrorHandler` that forwards to `AllStak.captureException`. It unwraps the common Angular/zone.js error envelopes (`ngOriginalError`, promise `rejection`, `HttpErrorResponse.error`, `ErrorEvent.error`) before capture.
+
+```ts
+import { ErrorHandler } from '@angular/core';
+import { createErrorHandler } from '@allstak/angular';
+
+providers: [
+  {
+    provide: ErrorHandler,
+    useValue: createErrorHandler({
+      logErrors: true, // also console.error the original (default)
+      extractor: (error, defaultExtractor) =>
+        (error as { cause?: unknown }).cause ?? defaultExtractor(error),
+    }),
+  },
+];
+```
+
+## Router instrumentation
+
+`TraceService` subscribes to Angular `Router` events and opens a `navigation` span per route change (finishing `ok` on `NavigationEnd`, `error` on `NavigationCancel` / `NavigationError`), plus a navigation breadcrumb. It must be force-instantiated — `provideAllStakRouterInstrumentation()` (standalone) or `AllStakModule.forRoot()` (NgModule) does that for you.
+
+## Component render timing
+
+The `[trace]` directive opens a `ui.angular.init` span between a component's `ngOnInit` and `ngAfterViewInit`. Import `TraceDirective` directly (standalone) or `AllStakTraceModule` (NgModule):
+
+```ts
+// standalone component
+import { Component } from '@angular/core';
+import { TraceDirective } from '@allstak/angular';
+
+@Component({
+  standalone: true,
+  imports: [TraceDirective],
+  template: `<section trace="dashboard">…</section>`,
+})
+export class DashboardComponent {}
+```
+
+You can also instrument classes/methods with the decorators (the `name` is required so spans survive minification):
+
+```ts
+import { TraceClassDecorator, TraceMethodDecorator } from '@allstak/angular';
+
+@TraceClassDecorator({ name: 'CheckoutComponent' })
+@Component({ /* … */ })
+export class CheckoutComponent {
+  @TraceMethodDecorator({ name: 'CheckoutComponent.ngOnInit' })
+  ngOnInit() {}
+}
+```
+
+## HTTP instrumentation
+
+The interceptor records every outbound request as an `outbound` HTTP item and opens a `http.client` span around it (finished `error` on `4xx`/`5xx` or transport failure). Use the functional `allStakHttpInterceptor` with `withInterceptors([...])` or the class `AllStakHttpInterceptor` with `HTTP_INTERCEPTORS`. It never mutates the request.
+
+## Configuration
+
+`init(config)`, `provideAllStak(config)`, and `AllStakModule.forRoot(config)` all accept every option that `@allstak/js`'s `AllStak.init` accepts. Common options:
+
+| Option | Purpose |
+|---|---|
+| `apiKey` | Ingest key (required) |
+| `host` | Override the ingest host |
+| `environment` | e.g. `'production'` / `'development'` |
+| `release` | Release identifier for issue grouping / release health |
+| `tracesSampleRate` | Span sampling rate (0–1) |
+| `enableWebVitals` | Capture web vitals |
+| `enableAutoSessionTracking` | Release-health sessions |
+| `enableOfflineQueue` | Buffer events while offline |
+| `beforeSend` | Mutate/drop events before they are sent |
+
+The full `@allstak/js` API is re-exported, so you can pull the entire observability surface from one import:
+
+```ts
+import * as AllStakAngular from '@allstak/angular';
+
+AllStakAngular.AllStak.captureMessage('checkout started', 'info');
+const span = AllStakAngular.AllStak.startSpan('checkout.flow', { description: 'review → pay' });
+span.finish('ok');
+```
+
+## License
+
+MIT

package/esm2022/allstak-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsc3Rhay1hbmd1bGFyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYWxsc3Rhay1hbmd1bGFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/public-api.mjs

@@ -0,0 +1,40 @@
+/**
+ * AllStak for Angular.
+ *
+ * Public surface:
+ *   - `init`                              — bootstrap (delegates to @allstak/js with Angular tagging)
+ *   - `createErrorHandler` / `AllStakErrorHandler` — Angular `ErrorHandler` forwarding to captureException
+ *   - `AllStakHttpInterceptor` / `allStakHttpInterceptor` — records outbound requests + opens spans
+ *   - `TraceService`                      — Router-aware navigation span instrumentation
+ *   - `TraceDirective` / `AllStakTraceModule` — `[trace]` component render-timing directive
+ *   - `TraceClassDecorator` / `TraceMethodDecorator` — lifecycle-span decorators
+ *   - `provideAllStak` / `provideAllStakErrorHandler` / `provideAllStakRouterInstrumentation`
+ *                                          — standalone provider functions
+ *   - `AllStakModule.forRoot(config)`     — NgModule registration for module-based apps
+ *   - re-exports                          — every top-level @allstak/js export
+ */
+// Bootstrap.
+export { init } from './src/init';
+// Error handling.
+export { createErrorHandler, AllStakErrorHandler, } from './src/error-handler';
+// HTTP instrumentation.
+export { AllStakHttpInterceptor, allStakHttpInterceptor, } from './src/http-interceptor';
+// Router / navigation instrumentation.
+export { TraceService } from './src/trace-service';
+// Component render-timing directive + module.
+export { TraceDirective } from './src/trace-directive';
+// Lifecycle-span decorators.
+export { TraceClass, TraceClassDecorator, TraceMethod, TraceMethodDecorator, } from './src/trace-decorators';
+// Standalone provider functions.
+export { provideAllStak, provideAllStakErrorHandler, provideAllStakRouterInstrumentation, } from './src/providers';
+// NgModule registration for module-based apps.
+export { AllStakModule, AllStakTraceModule, ALLSTAK_CONFIG, appInitializerFactory, } from './src/module';
+// Wrapper identity.
+export { SDK_NAME, SDK_VERSION } from './src/version';
+// ---------------------------------------------------------------------------
+// Mirror the @allstak/js public surface so consumers can pull the entire
+// observability API from a single namespaced import:
+//   import * as AllStakAngular from '@allstak/angular';
+// ---------------------------------------------------------------------------
+export { AllStak, Scope, Session, SessionTracker, Span, WebVitalsModule, isWebVitalsSupported, defineIntegration, dedupeIntegration, consoleIntegration, httpClientIntegration, databaseIntegration, eventFiltersIntegration, inboundFiltersIntegration, } from '@allstak/js';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/error-handler.mjs

@@ -0,0 +1,112 @@
+import { Injectable } from '@angular/core';
+import { AllStak } from '@allstak/js';
+import * as i0 from "@angular/core";
+const DEFAULT_OPTIONS = {
+    logErrors: true,
+};
+/**
+ * Unwrap the common Angular/zone.js error envelopes so we capture the real
+ * underlying error rather than the wrapper:
+ *
+ *   - Angular wraps errors thrown during change detection as
+ *     `{ ngOriginalError }` / `{ originalError }`.
+ *   - `HttpErrorResponse` carries the server payload on `.error`.
+ *   - DOM `ErrorEvent` carries the real error on `.error`.
+ *   - Rejected promises may surface as `{ rejection }`.
+ */
+function defaultExtractor(error) {
+    if (error && typeof error === 'object') {
+        const candidate = error;
+        // PromiseRejectionEvent-style wrapping from zone.js.
+        if ('rejection' in candidate && candidate['rejection'] != null) {
+            return defaultExtractor(candidate['rejection']);
+        }
+        // Angular wraps the thrown value during change detection.
+        if ('ngOriginalError' in candidate && candidate['ngOriginalError'] != null) {
+            return defaultExtractor(candidate['ngOriginalError']);
+        }
+        if ('originalError' in candidate && candidate['originalError'] != null) {
+            return defaultExtractor(candidate['originalError']);
+        }
+        // DOM ErrorEvent / HttpErrorResponse expose the real error on `.error`.
+        if ('error' in candidate && candidate['error'] instanceof Error) {
+            return candidate['error'];
+        }
+    }
+    return error;
+}
+/** Coerce any extracted value into an `Error` so `captureException` is happy. */
+function toError(value) {
+    if (value instanceof Error)
+        return value;
+    if (typeof value === 'string')
+        return new Error(value);
+    try {
+        return new Error(JSON.stringify(value));
+    }
+    catch {
+        return new Error(String(value));
+    }
+}
+/**
+ * AllStak's implementation of Angular's `ErrorHandler`. Captures every error
+ * routed through Angular's global error handling — uncaught render/lifecycle
+ * errors, change-detection errors, and (when zone.js is present) unhandled
+ * promise rejections.
+ *
+ * Wired manually as `{ provide: ErrorHandler, useValue: createErrorHandler() }`
+ * or via {@link provideAllStakErrorHandler}.
+ */
+export class AllStakErrorHandler {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    handleError(error) {
+        const extracted = this.options.extractor
+            ? this.options.extractor(error, defaultExtractor)
+            : defaultExtractor(error);
+        const err = toError(extracted);
+        try {
+            AllStak.captureException(err, { framework: 'angular' });
+        }
+        catch {
+            // Never let our handler break the host's error path.
+        }
+        if (this.options.logErrors !== false) {
+            // Preserve Angular's default of surfacing the original (pre-unwrap)
+            // value so stack traces and zone context stay intact in the console.
+            // eslint-disable-next-line no-console
+            console.error(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined }] });
+/**
+ * Factory returning an Angular `ErrorHandler` that forwards to
+ * `AllStak.captureException`.
+ *
+ * Standalone (`app.config.ts`):
+ *
+ *   import { ErrorHandler } from '@angular/core';
+ *   import { createErrorHandler } from '@allstak/angular';
+ *
+ *   export const appConfig = {
+ *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],
+ *   };
+ *
+ * NgModule (`AppModule`):
+ *
+ *   @NgModule({
+ *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],
+ *   })
+ *   export class AppModule {}
+ */
+export function createErrorHandler(options) {
+    return new AllStakErrorHandler(options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.js","sourceRoot":"","sources":["../../../src/error-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { ErrorHandler, Injectable } from '@angular/core';\nimport { AllStak } from '@allstak/js';\n\n/**\n * Options accepted by {@link createErrorHandler} / {@link AllStakErrorHandler}.\n *\n * Mirrors the shape host apps expect from a framework error-handler factory:\n * a logging toggle and an `extractor` escape hatch so the host can customise\n * how a thrown value is unwrapped before we hand it to `captureException`.\n */\nexport interface ErrorHandlerOptions {\n  /**\n   * Also `console.error` the original error after capturing it. Default:\n   * `true` — preserving Angular's default behaviour of surfacing errors to\n   * the console so local development is not silenced.\n   */\n  logErrors?: boolean;\n\n  /**\n   * Customise how the thrown value is reduced to the `Error` we capture.\n   * Receives the raw value Angular handed to `handleError` plus the SDK's\n   * `defaultExtractor`, so a host can fall back to default behaviour for\n   * cases it does not care about.\n   *\n   *   createErrorHandler({\n   *     extractor: (error, defaultExtractor) =>\n   *       error?.customCause ?? defaultExtractor(error),\n   *   });\n   */\n  extractor?: (error: unknown, defaultExtractor: (error: unknown) => unknown) => unknown;\n}\n\nconst DEFAULT_OPTIONS: Required<Pick<ErrorHandlerOptions, 'logErrors'>> = {\n  logErrors: true,\n};\n\n/**\n * Unwrap the common Angular/zone.js error envelopes so we capture the real\n * underlying error rather than the wrapper:\n *\n *   - Angular wraps errors thrown during change detection as\n *     `{ ngOriginalError }` / `{ originalError }`.\n *   - `HttpErrorResponse` carries the server payload on `.error`.\n *   - DOM `ErrorEvent` carries the real error on `.error`.\n *   - Rejected promises may surface as `{ rejection }`.\n */\nfunction defaultExtractor(error: unknown): unknown {\n  if (error && typeof error === 'object') {\n    const candidate = error as Record<string, unknown>;\n    // PromiseRejectionEvent-style wrapping from zone.js.\n    if ('rejection' in candidate && candidate['rejection'] != null) {\n      return defaultExtractor(candidate['rejection']);\n    }\n    // Angular wraps the thrown value during change detection.\n    if ('ngOriginalError' in candidate && candidate['ngOriginalError'] != null) {\n      return defaultExtractor(candidate['ngOriginalError']);\n    }\n    if ('originalError' in candidate && candidate['originalError'] != null) {\n      return defaultExtractor(candidate['originalError']);\n    }\n    // DOM ErrorEvent / HttpErrorResponse expose the real error on `.error`.\n    if ('error' in candidate && candidate['error'] instanceof Error) {\n      return candidate['error'];\n    }\n  }\n  return error;\n}\n\n/** Coerce any extracted value into an `Error` so `captureException` is happy. */\nfunction toError(value: unknown): Error {\n  if (value instanceof Error) return value;\n  if (typeof value === 'string') return new Error(value);\n  try {\n    return new Error(JSON.stringify(value));\n  } catch {\n    return new Error(String(value));\n  }\n}\n\n/**\n * AllStak's implementation of Angular's `ErrorHandler`. Captures every error\n * routed through Angular's global error handling — uncaught render/lifecycle\n * errors, change-detection errors, and (when zone.js is present) unhandled\n * promise rejections.\n *\n * Wired manually as `{ provide: ErrorHandler, useValue: createErrorHandler() }`\n * or via {@link provideAllStakErrorHandler}.\n */\n@Injectable()\nexport class AllStakErrorHandler implements ErrorHandler {\n  private readonly options: ErrorHandlerOptions;\n\n  constructor(options: ErrorHandlerOptions = {}) {\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n  }\n\n  handleError(error: unknown): void {\n    const extracted = this.options.extractor\n      ? this.options.extractor(error, defaultExtractor)\n      : defaultExtractor(error);\n\n    const err = toError(extracted);\n\n    try {\n      AllStak.captureException(err, { framework: 'angular' });\n    } catch {\n      // Never let our handler break the host's error path.\n    }\n\n    if (this.options.logErrors !== false) {\n      // Preserve Angular's default of surfacing the original (pre-unwrap)\n      // value so stack traces and zone context stay intact in the console.\n      // eslint-disable-next-line no-console\n      console.error(error);\n    }\n  }\n}\n\n/**\n * Factory returning an Angular `ErrorHandler` that forwards to\n * `AllStak.captureException`.\n *\n * Standalone (`app.config.ts`):\n *\n *   import { ErrorHandler } from '@angular/core';\n *   import { createErrorHandler } from '@allstak/angular';\n *\n *   export const appConfig = {\n *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],\n *   };\n *\n * NgModule (`AppModule`):\n *\n *   @NgModule({\n *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],\n *   })\n *   export class AppModule {}\n */\nexport function createErrorHandler(options?: ErrorHandlerOptions): ErrorHandler {\n  return new AllStakErrorHandler(options);\n}\n"]}

package/esm2022/src/http-interceptor.mjs

@@ -0,0 +1,158 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { AllStak } from '@allstak/js';
+import * as i0 from "@angular/core";
+const KNOWN_METHODS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'HEAD',
+    'OPTIONS',
+]);
+/** Normalise an Angular request method into the core method union. */
+function normalizeMethod(method) {
+    const upper = method.toUpperCase();
+    return (KNOWN_METHODS.has(upper) ? upper : 'GET');
+}
+/** Split an outbound URL into `host` + `path`, tolerating relative URLs. */
+function splitUrl(url) {
+    try {
+        const base = typeof window !== 'undefined' && window.location
+            ? window.location.origin
+            : 'http://localhost';
+        const parsed = new URL(url, base);
+        return { host: parsed.host, path: parsed.pathname + parsed.search };
+    }
+    catch {
+        return { host: '', path: url };
+    }
+}
+/**
+ * Open a span + record an outbound request for a single `HttpRequest`, and
+ * return the lifecycle hooks the interceptor (class or functional) uses to
+ * finish it. Shared so the class-based and functional interceptors stay
+ * behaviourally identical.
+ */
+function instrumentRequest(req) {
+    const startedAt = Date.now();
+    const method = normalizeMethod(req.method);
+    const { host, path } = splitUrl(req.urlWithParams);
+    let span = null;
+    try {
+        span = AllStak.startSpan('http.client', {
+            op: 'http.client',
+            description: `${req.method} ${req.urlWithParams}`,
+            attributes: {
+                'allstak.origin': 'auto.http.angular',
+                'http.method': req.method,
+                'http.url': req.urlWithParams,
+            },
+        });
+    }
+    catch {
+        // Never block the request on observability errors.
+    }
+    const finish = (statusCode, status) => {
+        const durationMs = Date.now() - startedAt;
+        try {
+            span?.setMeasurement('http.duration_ms', durationMs);
+            span?.finish(status);
+        }
+        catch {
+            // ignore — span may already be finished
+        }
+        try {
+            const item = {
+                direction: 'outbound',
+                method,
+                host,
+                path,
+                statusCode,
+                durationMs,
+            };
+            AllStak.captureRequest(item);
+        }
+        catch {
+            // ignore — request recording is best-effort
+        }
+    };
+    return {
+        onResponse(statusCode) {
+            finish(statusCode, statusCode >= 400 ? 'error' : 'ok');
+        },
+        onError(error) {
+            const statusCode = error instanceof HttpErrorResponse ? error.status : 0;
+            finish(statusCode, 'error');
+        },
+    };
+}
+/**
+ * Class-based `HttpInterceptor` that records every outbound HTTP request and
+ * opens a `http.client` span around it. Register in the DI-token style used by
+ * NgModule apps and standalone apps that opt into `withInterceptorsFromDi()`:
+ *
+ *   import { HTTP_INTERCEPTORS } from '@angular/common/http';
+ *   import { AllStakHttpInterceptor } from '@allstak/angular';
+ *
+ *   providers: [
+ *     { provide: HTTP_INTERCEPTORS, useClass: AllStakHttpInterceptor, multi: true },
+ *   ]
+ *
+ * The interceptor never mutates the request and never swallows errors — it
+ * only observes the stream.
+ */
+export class AllStakHttpInterceptor {
+    intercept(req, next) {
+        const hooks = instrumentRequest(req);
+        return new Observable((subscriber) => {
+            const sub = next.handle(req).subscribe({
+                next: (event) => {
+                    if (event instanceof HttpResponse) {
+                        hooks.onResponse(event.status);
+                    }
+                    subscriber.next(event);
+                },
+                error: (error) => {
+                    hooks.onError(error);
+                    subscriber.error(error);
+                },
+                complete: () => subscriber.complete(),
+            });
+            return () => sub.unsubscribe();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Functional `HttpInterceptor` for standalone apps using
+ * `provideHttpClient(withInterceptors([allStakHttpInterceptor]))`.
+ *
+ * Behaviourally identical to {@link AllStakHttpInterceptor}.
+ */
+export function allStakHttpInterceptor(req, next) {
+    const hooks = instrumentRequest(req);
+    return new Observable((subscriber) => {
+        const sub = next(req).subscribe({
+            next: (event) => {
+                if (event instanceof HttpResponse) {
+                    hooks.onResponse(event.status);
+                }
+                subscriber.next(event);
+            },
+            error: (error) => {
+                hooks.onError(error);
+                subscriber.error(error);
+            },
+            complete: () => subscriber.complete(),
+        });
+        return () => sub.unsubscribe();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-interceptor.js","sourceRoot":"","sources":["../../../src/http-interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport type {\n  HttpEvent,\n  HttpHandler,\n  HttpInterceptor,\n  HttpHandlerFn,\n  HttpRequest,\n} from '@angular/common/http';\nimport { HttpResponse, HttpErrorResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { AllStak } from '@allstak/js';\nimport type { HttpRequestItem, Span } from '@allstak/js';\n\n/** HTTP verbs the core `HttpRequestItem` accepts. */\ntype HttpMethod = HttpRequestItem['method'];\n\nconst KNOWN_METHODS: ReadonlySet<string> = new Set([\n  'GET',\n  'POST',\n  'PUT',\n  'DELETE',\n  'PATCH',\n  'HEAD',\n  'OPTIONS',\n]);\n\n/** Normalise an Angular request method into the core method union. */\nfunction normalizeMethod(method: string): HttpMethod {\n  const upper = method.toUpperCase();\n  return (KNOWN_METHODS.has(upper) ? upper : 'GET') as HttpMethod;\n}\n\n/** Split an outbound URL into `host` + `path`, tolerating relative URLs. */\nfunction splitUrl(url: string): { host: string; path: string } {\n  try {\n    const base =\n      typeof window !== 'undefined' && window.location\n        ? window.location.origin\n        : 'http://localhost';\n    const parsed = new URL(url, base);\n    return { host: parsed.host, path: parsed.pathname + parsed.search };\n  } catch {\n    return { host: '', path: url };\n  }\n}\n\n/**\n * Open a span + record an outbound request for a single `HttpRequest`, and\n * return the lifecycle hooks the interceptor (class or functional) uses to\n * finish it. Shared so the class-based and functional interceptors stay\n * behaviourally identical.\n */\nfunction instrumentRequest(req: HttpRequest<unknown>): {\n  onResponse: (status: number) => void;\n  onError: (error: unknown) => void;\n} {\n  const startedAt = Date.now();\n  const method = normalizeMethod(req.method);\n  const { host, path } = splitUrl(req.urlWithParams);\n  let span: Span | null = null;\n\n  try {\n    span = AllStak.startSpan('http.client', {\n      op: 'http.client',\n      description: `${req.method} ${req.urlWithParams}`,\n      attributes: {\n        'allstak.origin': 'auto.http.angular',\n        'http.method': req.method,\n        'http.url': req.urlWithParams,\n      },\n    });\n  } catch {\n    // Never block the request on observability errors.\n  }\n\n  const finish = (statusCode: number, status: 'ok' | 'error') => {\n    const durationMs = Date.now() - startedAt;\n    try {\n      span?.setMeasurement('http.duration_ms', durationMs);\n      span?.finish(status);\n    } catch {\n      // ignore — span may already be finished\n    }\n    try {\n      const item: HttpRequestItem = {\n        direction: 'outbound',\n        method,\n        host,\n        path,\n        statusCode,\n        durationMs,\n      };\n      AllStak.captureRequest(item);\n    } catch {\n      // ignore — request recording is best-effort\n    }\n  };\n\n  return {\n    onResponse(statusCode: number) {\n      finish(statusCode, statusCode >= 400 ? 'error' : 'ok');\n    },\n    onError(error: unknown) {\n      const statusCode = error instanceof HttpErrorResponse ? error.status : 0;\n      finish(statusCode, 'error');\n    },\n  };\n}\n\n/**\n * Class-based `HttpInterceptor` that records every outbound HTTP request and\n * opens a `http.client` span around it. Register in the DI-token style used by\n * NgModule apps and standalone apps that opt into `withInterceptorsFromDi()`:\n *\n *   import { HTTP_INTERCEPTORS } from '@angular/common/http';\n *   import { AllStakHttpInterceptor } from '@allstak/angular';\n *\n *   providers: [\n *     { provide: HTTP_INTERCEPTORS, useClass: AllStakHttpInterceptor, multi: true },\n *   ]\n *\n * The interceptor never mutates the request and never swallows errors — it\n * only observes the stream.\n */\n@Injectable()\nexport class AllStakHttpInterceptor implements HttpInterceptor {\n  intercept(\n    req: HttpRequest<unknown>,\n    next: HttpHandler,\n  ): Observable<HttpEvent<unknown>> {\n    const hooks = instrumentRequest(req);\n\n    return new Observable<HttpEvent<unknown>>((subscriber) => {\n      const sub = next.handle(req).subscribe({\n        next: (event) => {\n          if (event instanceof HttpResponse) {\n            hooks.onResponse(event.status);\n          }\n          subscriber.next(event);\n        },\n        error: (error) => {\n          hooks.onError(error);\n          subscriber.error(error);\n        },\n        complete: () => subscriber.complete(),\n      });\n      return () => sub.unsubscribe();\n    });\n  }\n}\n\n/**\n * Functional `HttpInterceptor` for standalone apps using\n * `provideHttpClient(withInterceptors([allStakHttpInterceptor]))`.\n *\n * Behaviourally identical to {@link AllStakHttpInterceptor}.\n */\nexport function allStakHttpInterceptor(\n  req: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n): Observable<HttpEvent<unknown>> {\n  const hooks = instrumentRequest(req);\n\n  return new Observable<HttpEvent<unknown>>((subscriber) => {\n    const sub = next(req).subscribe({\n      next: (event) => {\n        if (event instanceof HttpResponse) {\n          hooks.onResponse(event.status);\n        }\n        subscriber.next(event);\n      },\n      error: (error) => {\n        hooks.onError(error);\n        subscriber.error(error);\n      },\n      complete: () => subscriber.complete(),\n    });\n    return () => sub.unsubscribe();\n  });\n}\n"]}