@bsb/observable-axiom 1.0.0 → 1.1.2

package/README.md

@@ -1,15 +1,14 @@
-# BSB Observable Axiom
+# @bsb/observable-axiom
 
-Axiom.co integration for the Better Service Base (BSB) framework - unified observability for logs, metrics, and traces.
+Axiom.co observability integration for BSB. Exports logs, metrics, and traces to Axiom with OTLP tracing support.
 
-## Features
+## Key Features
 
-- **Unified Observability** - Logs, metrics, and traces in one platform
-- **Axiom SDK** - Official `@axiomhq/js` for logs and events
-- **OpenTelemetry Traces** - OTLP export to Axiom (native support)
-- **Structured Metrics** - Metrics as queryable events
-- **Batch Processing** - Efficient batching with configurable flush intervals
-- **Full TypeScript Support** - Type-safe configuration and no `any` types
+- Unified observability: logs, metrics, and traces
+- Axiom SDK for logs and events
+- OpenTelemetry tracing via OTLP
+- Batch processing with configurable flush interval
+- Resource attributes for consistent service metadata
 
 ## Installation
 
@@ -19,233 +18,85 @@ npm install @bsb/observable-axiom
 
 ## Configuration
 
-Add to your BSB configuration file:
+Add the plugin to your BSB configuration file:
 
 ```yaml
 plugins:
-  observable:
-    - observable-axiom
-
-observable-axiom:
-  serviceName: my-service
-  serviceVersion: 1.0.0
-
-  axiom:
-    token: ${AXIOM_TOKEN}           # Your Axiom API token
-    dataset: bsb-logs               # Axiom dataset name
-    orgId: ${AXIOM_ORG_ID}          # Optional: for Axiom Cloud
-    # url: https://axiom.mycompany.com  # Optional: for self-hosted
-
-  enabled:
-    logs: true
-    metrics: true
-    traces: true
-
-  export:
-    flushIntervalMs: 5000           # Flush every 5 seconds
-    maxBatchSize: 1000              # Max events per batch
-
-  # Optional resource attributes (added to all telemetry)
-  resourceAttributes:
-    environment: production
-    region: us-east-1
-    cluster: main
+  observables:
+    - plugin: "@bsb/observable-axiom"
+      enabled: true
+      config:
+        serviceName: "my-service"
+        serviceVersion: "1.0.0"
+        axiom:
+          token: "${AXIOM_TOKEN}"
+          dataset: "bsb-logs"
+          orgId: "${AXIOM_ORG_ID}"
+          # url: "https://axiom.mycompany.com" # Optional for self-hosted
+        enabled:
+          logs: true
+          metrics: true
+          traces: true
+        export:
+          flushIntervalMs: 5000
+          maxBatchSize: 1000
+        resourceAttributes:
+          environment: "production"
+          region: "us-east-1"
+          cluster: "main"
 ```
 
+### Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `serviceName` | Service identifier | `"bsb-service"` |
+| `serviceVersion` | Service version tag | - |
+| `axiom.token` | Axiom API token | Required |
+| `axiom.dataset` | Axiom dataset name | `"bsb-logs"` |
+| `axiom.orgId` | Organization ID (Axiom Cloud) | - |
+| `axiom.url` | Custom Axiom URL (self-hosted) | - |
+| `enabled.logs` | Enable log export | `true` |
+| `enabled.metrics` | Enable metric export | `true` |
+| `enabled.traces` | Enable trace export | `true` |
+| `export.flushIntervalMs` | Flush interval (ms) | `5000` |
+| `export.maxBatchSize` | Max events per batch | `1000` |
+| `resourceAttributes` | Custom attributes | `{}` |
+
 ## Environment Variables
 
 ```bash
-export AXIOM_TOKEN="xaat-your-token-here"
-export AXIOM_ORG_ID="your-org-id"  # Optional for cloud
-export AXIOM_DATASET="bsb-logs"
+AXIOM_TOKEN="xaat-your-token-here"
+AXIOM_ORG_ID="your-org-id"
+AXIOM_DATASET="bsb-logs"
 ```
 
-## What Gets Exported
-
-### Logs (to Axiom Dataset)
-- Structured JSON with trace context
-- Log levels: debug, info, warn, error
-- Plugin name and service metadata
-- Custom metadata from log calls
-- Resource attributes
-
-### Metrics (to Axiom Dataset as Events)
-- Counters, gauges, histograms
-- Stored as structured events
-- Queryable with Axiom Processing Language (APL)
-- Automatic timestamp and service tagging
-
-### Traces (to Axiom via OTLP)
-- Full distributed tracing
-- Span lifecycle (start, end, error)
-- Trace context propagation
-- Exception tracking
-
 ## Usage
 
-The plugin automatically integrates with BSB's Observable pattern:
+Once configured, logs, metrics, and traces are exported automatically:
 
 ```typescript
-export class MyService extends BSBService<InstanceType<typeof Config>, typeof EventSchemas> {
-  static Config = Config;
-  static EventSchemas = EventSchemas;
-
-  public async run(obs: Observable) {
-    // Logs automatically sent to Axiom
-    obs.log.info("Service started", { userId: 123 });
-
-    // Create child span (sent to Axiom traces)
-    const workObs = obs.span("process-request");
-    workObs.setAttribute("request.id", "req-123");
-
-    try {
-      await this.processRequest();
-      workObs.end();
-    } catch (error) {
-      workObs.recordException(error);
-      workObs.end();
-    }
-
-    // Metrics also sent to Axiom
-    // (BSB metrics API will emit these as events)
-  }
-}
-```
-
-## Axiom Setup
-
-### 1. Create Account
-Sign up at https://axiom.co
-
-### 2. Create Dataset
-```bash
-axiom dataset create bsb-logs
-```
-
-### 3. Create API Token
-```bash
-axiom token create bsb-ingest --scopes ingest --datasets bsb-logs
-```
-
-### 4. Configure BSB
-Add token to your configuration or environment variables.
-
-## Querying Data in Axiom
-
-### Logs Query (APL)
-```apl
-['bsb-logs']
-| where service == "my-service"
-| where level == "error"
-| order by _time desc
-| limit 100
+this.log.info("Service started", { userId: 123 });
+const workObs = this.obs.span("process-request");
+await this.events.emitEvent("user.created", { userId: "123" });
+workObs.end();
 ```
 
-### Metrics Query
-```apl
-['bsb-logs']
-| where metric_type == "counter"
-| where metric_name == "requests_total"
-| summarize sum(value) by bin(_time, 1m)
-```
+## Axiom Setup (Quick)
 
-### Trace Analysis
-Use Axiom's Trace view to explore distributed traces with automatic service maps and performance analytics.
+1. Create a dataset
+2. Create an ingest token with dataset access
+3. Set `AXIOM_TOKEN` and `AXIOM_DATASET` in the environment
 
-## Architecture
+## Documentation
 
-```
-BSB Application
-    ↓
-Observable (DTrace)
-    ↓
-observable-axiom
-    ├── Logs/Metrics → Axiom SDK → Axiom Dataset
-    └── Traces → OTLP Exporter → Axiom Traces
-```
+Detailed documentation (used by the BSB Registry): `https://github.com/BetterCorp/better-service-base/blob/master/plugins/nodejs/observable-axiom/docs/plugin.md`
 
-## Configuration Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `serviceName` | string | `"bsb-service"` | Service identifier |
-| `serviceVersion` | string | - | Service version tag |
-| `axiom.token` | string | **required** | Axiom API token |
-| `axiom.dataset` | string | `"bsb-logs"` | Dataset name |
-| `axiom.orgId` | string | - | Organization ID (cloud) |
-| `axiom.url` | string | - | Custom URL (self-hosted) |
-| `enabled.logs` | boolean | `true` | Enable log export |
-| `enabled.metrics` | boolean | `true` | Enable metrics export |
-| `enabled.traces` | boolean | `true` | Enable trace export |
-| `export.flushIntervalMs` | number | `5000` | Flush interval (ms) |
-| `export.maxBatchSize` | number | `1000` | Max events per batch |
-| `resourceAttributes` | object | `{}` | Custom attributes |
-
-## Comparison with Other Observability Plugins
-
-| Plugin | Logs | Metrics | Traces | Backend |
-|--------|------|---------|--------|---------|
-| observable-axiom | ✅ | ✅ | ✅ | Axiom.co |
-| observable-opentelemetry | ✅ | ✅ | ✅ | OTLP Collector |
-| observable-zipkin | Console | ❌ | ✅ | Zipkin |
-| observable-default | Console | ❌ | ❌ | - |
-
-## Best Practices
-
-### 1. Use Datasets Strategically
-```yaml
-# Production
-axiom:
-  dataset: prod-logs
+## Links
 
-# Development
-axiom:
-  dataset: dev-logs
-```
-
-### 2. Set Resource Attributes
-```yaml
-resourceAttributes:
-  environment: ${ENVIRONMENT}
-  deployment: ${DEPLOYMENT_ID}
-  datacenter: ${DATACENTER}
-```
-
-### 3. Control Batch Size
-```yaml
-export:
-  # High-volume services
-  flushIntervalMs: 1000
-  maxBatchSize: 5000
-
-  # Low-volume services
-  flushIntervalMs: 10000
-  maxBatchSize: 100
-```
-
-### 4. Use Structured Logging
-```typescript
-// Good - queryable fields
-obs.log.info("User logged in", {
-  userId: user.id,
-  email: user.email
-});
-
-// Bad - unstructured
-obs.log.info(`User ${user.email} logged in`);
-```
-
-## Axiom Features
-
-- **APL (Axiom Processing Language)** - Powerful query language
-- **Service Maps** - Automatic trace visualization
-- **Monitors & Alerts** - Real-time alerting on anomalies
-- **Dashboards** - Custom visualizations
-- **Notebooks** - Collaborative analysis
-- **Retention** - Configurable data retention policies
+- GitHub: `https://github.com/BetterCorp/better-service-base/tree/master/plugins/nodejs/observable-axiom`
+- BSB Registry (package): `https://io.bsbcode.dev/packages/nodejs/@bsb/observable-axiom`
 
 ## License
 
-AGPL-3.0 - See LICENSE file for details.
-
-Commercial licenses available at https://www.bettercorp.dev
+(AGPL-3.0-only OR Commercial)

package/bsb-tests.json

@@ -0,0 +1,14 @@
+{
+  "nodejs": [
+    {
+      "id": "observable-axiom",
+      "skip": true,
+      "default": {
+        "config": {},
+        "setup": null,
+        "dispose": null
+      },
+      "tests": []
+    }
+  ]
+}

package/lib/plugins/observable-axiom/index.d.ts

@@ -26,27 +26,27 @@
  */
 import { BSBObservable, BSBObservableConstructor, BSBError } from "@bsb/base";
 import { DTrace, LogMeta } from "@bsb/base";
-import { z } from "zod";
-export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
-    serviceName: z.ZodDefault<z.ZodString>;
-    serviceVersion: z.ZodOptional<z.ZodString>;
-    axiom: z.ZodObject<{
-        token: z.ZodString;
-        dataset: z.ZodDefault<z.ZodString>;
-        orgId: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodURL>;
-    }, z.core.$strip>;
-    enabled: z.ZodObject<{
-        logs: z.ZodDefault<z.ZodBoolean>;
-        metrics: z.ZodDefault<z.ZodBoolean>;
-        traces: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
-    export: z.ZodObject<{
-        flushIntervalMs: z.ZodDefault<z.ZodNumber>;
-        maxBatchSize: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>;
-    resourceAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>>;
+import * as av from "@anyvali/js";
+export declare const Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
+    serviceName: av.OptionalSchema<av.StringSchema>;
+    serviceVersion: av.OptionalSchema<av.StringSchema>;
+    axiom: av.ObjectSchema<{
+        token: av.StringSchema;
+        dataset: av.OptionalSchema<av.StringSchema>;
+        orgId: av.OptionalSchema<av.StringSchema>;
+        url: av.OptionalSchema<av.StringSchema>;
+    }>;
+    enabled: av.ObjectSchema<{
+        logs: av.OptionalSchema<av.BoolSchema>;
+        metrics: av.OptionalSchema<av.BoolSchema>;
+        traces: av.OptionalSchema<av.BoolSchema>;
+    }>;
+    export: av.ObjectSchema<{
+        flushIntervalMs: av.OptionalSchema<av.Int32Schema>;
+        maxBatchSize: av.OptionalSchema<av.Int32Schema>;
+    }>;
+    resourceAttributes: av.OptionalSchema<av.RecordSchema<av.StringSchema>>;
+}>>;
 /**
  * Axiom observable plugin for unified observability
  *
@@ -55,26 +55,26 @@ export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObjec
  * Exports metrics as structured events
  */
 export declare class Plugin extends BSBObservable<InstanceType<typeof Config>> {
-    static Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
-        serviceName: z.ZodDefault<z.ZodString>;
-        serviceVersion: z.ZodOptional<z.ZodString>;
-        axiom: z.ZodObject<{
-            token: z.ZodString;
-            dataset: z.ZodDefault<z.ZodString>;
-            orgId: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>;
-        enabled: z.ZodObject<{
-            logs: z.ZodDefault<z.ZodBoolean>;
-            metrics: z.ZodDefault<z.ZodBoolean>;
-            traces: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>;
-        export: z.ZodObject<{
-            flushIntervalMs: z.ZodDefault<z.ZodNumber>;
-            maxBatchSize: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>;
-        resourceAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>>;
+    static Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
+        serviceName: av.OptionalSchema<av.StringSchema>;
+        serviceVersion: av.OptionalSchema<av.StringSchema>;
+        axiom: av.ObjectSchema<{
+            token: av.StringSchema;
+            dataset: av.OptionalSchema<av.StringSchema>;
+            orgId: av.OptionalSchema<av.StringSchema>;
+            url: av.OptionalSchema<av.StringSchema>;
+        }>;
+        enabled: av.ObjectSchema<{
+            logs: av.OptionalSchema<av.BoolSchema>;
+            metrics: av.OptionalSchema<av.BoolSchema>;
+            traces: av.OptionalSchema<av.BoolSchema>;
+        }>;
+        export: av.ObjectSchema<{
+            flushIntervalMs: av.OptionalSchema<av.Int32Schema>;
+            maxBatchSize: av.OptionalSchema<av.Int32Schema>;
+        }>;
+        resourceAttributes: av.OptionalSchema<av.RecordSchema<av.StringSchema>>;
+    }>>;
     private logFormatter;
     private axiom;
     private tracerProvider;

package/lib/plugins/observable-axiom/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * BSB (Better-Service-Base) is an event-bus based microservice framework.
  * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
@@ -25,71 +24,36 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Plugin = exports.Config = void 0;
-const base_1 = require("@bsb/base");
-const zod_1 = require("zod");
-const js_1 = require("@axiomhq/js");
-const api = __importStar(require("@opentelemetry/api"));
-const resources_1 = require("@opentelemetry/resources");
-const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
-const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
-const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
-const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
-const ConfigSchema = zod_1.z.object({
-    serviceName: zod_1.z.string().default("bsb-service"),
-    serviceVersion: zod_1.z.string().optional(),
-    axiom: zod_1.z.object({
-        token: zod_1.z.string().describe("Axiom API token"),
-        dataset: zod_1.z.string().default("bsb-logs").describe("Axiom dataset name"),
-        orgId: zod_1.z.string().optional().describe("Axiom organization ID (for cloud)"),
-        url: zod_1.z.url().optional().describe("Custom Axiom URL (for self-hosted)"),
-    }),
-    enabled: zod_1.z.object({
-        logs: zod_1.z.boolean().default(true),
-        metrics: zod_1.z.boolean().default(true),
-        traces: zod_1.z.boolean().default(true),
-    }),
-    export: zod_1.z.object({
-        flushIntervalMs: zod_1.z.number().int().min(100).default(5000),
-        maxBatchSize: zod_1.z.number().int().min(1).default(1000),
-    }),
-    resourceAttributes: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).default({}),
-});
-exports.Config = (0, base_1.createConfigSchema)({
+import { BSBObservable, createConfigSchema, LogFormatter, BSBError } from "@bsb/base";
+import * as av from "@anyvali/js";
+import { Axiom } from "@axiomhq/js";
+import * as api from "@opentelemetry/api";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+const ConfigSchema = av.object({
+    serviceName: av.optional(av.string()).default("bsb-service"),
+    serviceVersion: av.optional(av.string()),
+    axiom: av.object({
+        token: av.string(),
+        dataset: av.optional(av.string()).default("bsb-logs"),
+        orgId: av.optional(av.string()),
+        url: av.optional(av.string().format("url")),
+    }, { unknownKeys: "strip" }),
+    enabled: av.object({
+        logs: av.optional(av.bool()).default(true),
+        metrics: av.optional(av.bool()).default(true),
+        traces: av.optional(av.bool()).default(true),
+    }, { unknownKeys: "strip" }),
+    export: av.object({
+        flushIntervalMs: av.optional(av.int32().min(100)).default(5000),
+        maxBatchSize: av.optional(av.int32().min(1)).default(1000),
+    }, { unknownKeys: "strip" }),
+    resourceAttributes: av.optional(av.record(av.string())).default({}),
+}, { unknownKeys: "strip" });
+export const Config = createConfigSchema({
     name: 'observable-axiom',
     description: 'Axiom.co observability integration for logs, metrics, and traces',
     version: '1.0.0',
@@ -140,10 +104,10 @@ class BSBIdGenerator {
  * Exports traces via OTLP (Axiom supports OpenTelemetry)
  * Exports metrics as structured events
  */
-class Plugin extends base_1.BSBObservable {
+export class Plugin extends BSBObservable {
     constructor(config) {
         super(config);
-        this.logFormatter = new base_1.LogFormatter();
+        this.logFormatter = new LogFormatter();
         this.axiom = null;
         this.tracerProvider = null;
         this.tracer = null;
@@ -165,20 +129,20 @@ class Plugin extends base_1.BSBObservable {
             if (this.config.axiom.url) {
                 axiomOptions.url = this.config.axiom.url;
             }
-            this.axiom = new js_1.Axiom(axiomOptions);
+            this.axiom = new Axiom(axiomOptions);
         }
         // Initialize OpenTelemetry for traces (Axiom supports OTLP natively)
         if (this.config.enabled.traces) {
-            const resource = (0, resources_1.defaultResource)().merge((0, resources_1.resourceFromAttributes)({
-                [semantic_conventions_1.ATTR_SERVICE_NAME]: this.config.serviceName,
-                ...(this.config.serviceVersion && { [semantic_conventions_1.ATTR_SERVICE_VERSION]: this.config.serviceVersion }),
+            const resource = defaultResource().merge(resourceFromAttributes({
+                [ATTR_SERVICE_NAME]: this.config.serviceName,
+                ...(this.config.serviceVersion && { [ATTR_SERVICE_VERSION]: this.config.serviceVersion }),
                 ...this.config.resourceAttributes,
             }));
             // Axiom OTLP endpoint (from docs: https://axiom.co/docs/send-data/opentelemetry)
             const otlpUrl = this.config.axiom.url
                 ? `${this.config.axiom.url}/v1/traces`
                 : `https://api.axiom.co/v1/traces`;
-            const traceExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            const traceExporter = new OTLPTraceExporter({
                 url: otlpUrl,
                 headers: {
                     "Authorization": `Bearer ${this.config.axiom.token}`,
@@ -189,11 +153,11 @@ class Plugin extends base_1.BSBObservable {
             this.idGenerator = new BSBIdGenerator();
             // Create tracer provider with custom ID generator and span processor
             // Use shorter batch delay for faster exports during debugging
-            this.tracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            this.tracerProvider = new NodeTracerProvider({
                 resource,
                 idGenerator: this.idGenerator,
                 spanProcessors: [
-                    new sdk_trace_base_1.BatchSpanProcessor(traceExporter, {
+                    new BatchSpanProcessor(traceExporter, {
                         scheduledDelayMillis: 1000, // Export every 1 second (default is 5000)
                         maxQueueSize: 2048,
                         maxExportBatchSize: 512,
@@ -280,7 +244,7 @@ class Plugin extends base_1.BSBObservable {
         this.queueLog("warn", trace, pluginName, message, meta);
     }
     error(trace, pluginName, message, meta) {
-        if (message instanceof base_1.BSBError) {
+        if (message instanceof BSBError) {
             if (message.raw !== null) {
                 this.queueLog("error", message.raw.trace, pluginName, message.raw.message, message.raw.meta);
             }
@@ -441,5 +405,4 @@ class Plugin extends base_1.BSBObservable {
         this.axiom = null;
     }
 }
-exports.Plugin = Plugin;
-Plugin.Config = exports.Config;
+Plugin.Config = Config;

package/lib/schemas/observable-axiom.json

@@ -2,110 +2,6 @@
   "pluginName": "observable-axiom",
   "version": "1.0.0",
   "events": {},
-  "configSchema": {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "type": "object",
-    "properties": {
-      "serviceName": {
-        "default": "bsb-service",
-        "type": "string"
-      },
-      "serviceVersion": {
-        "type": "string"
-      },
-      "axiom": {
-        "type": "object",
-        "properties": {
-          "token": {
-            "type": "string",
-            "description": "Axiom API token"
-          },
-          "dataset": {
-            "default": "bsb-logs",
-            "description": "Axiom dataset name",
-            "type": "string"
-          },
-          "orgId": {
-            "description": "Axiom organization ID (for cloud)",
-            "type": "string"
-          },
-          "url": {
-            "description": "Custom Axiom URL (for self-hosted)",
-            "type": "string",
-            "format": "uri"
-          }
-        },
-        "required": [
-          "token",
-          "dataset"
-        ],
-        "additionalProperties": false
-      },
-      "enabled": {
-        "type": "object",
-        "properties": {
-          "logs": {
-            "default": true,
-            "type": "boolean"
-          },
-          "metrics": {
-            "default": true,
-            "type": "boolean"
-          },
-          "traces": {
-            "default": true,
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "logs",
-          "metrics",
-          "traces"
-        ],
-        "additionalProperties": false
-      },
-      "export": {
-        "type": "object",
-        "properties": {
-          "flushIntervalMs": {
-            "default": 5000,
-            "type": "integer",
-            "minimum": 100,
-            "maximum": 9007199254740991
-          },
-          "maxBatchSize": {
-            "default": 1000,
-            "type": "integer",
-            "minimum": 1,
-            "maximum": 9007199254740991
-          }
-        },
-        "required": [
-          "flushIntervalMs",
-          "maxBatchSize"
-        ],
-        "additionalProperties": false
-      },
-      "resourceAttributes": {
-        "default": {},
-        "type": "object",
-        "propertyNames": {
-          "type": "string"
-        },
-        "additionalProperties": {
-          "type": "string"
-        }
-      }
-    },
-    "required": [
-      "serviceName",
-      "axiom",
-      "enabled",
-      "export",
-      "resourceAttributes"
-    ],
-    "additionalProperties": false
-  },
   "pluginType": "observable",
   "capabilities": {
     "logging": {

package/lib/schemas/observable-axiom.plugin.json

@@ -14,109 +14,5 @@
   ],
   "documentation": [],
   "dependencies": [],
-  "image": "./axiom-co-logo.png",
-  "configSchema": {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "type": "object",
-    "properties": {
-      "serviceName": {
-        "default": "bsb-service",
-        "type": "string"
-      },
-      "serviceVersion": {
-        "type": "string"
-      },
-      "axiom": {
-        "type": "object",
-        "properties": {
-          "token": {
-            "type": "string",
-            "description": "Axiom API token"
-          },
-          "dataset": {
-            "default": "bsb-logs",
-            "description": "Axiom dataset name",
-            "type": "string"
-          },
-          "orgId": {
-            "description": "Axiom organization ID (for cloud)",
-            "type": "string"
-          },
-          "url": {
-            "description": "Custom Axiom URL (for self-hosted)",
-            "type": "string",
-            "format": "uri"
-          }
-        },
-        "required": [
-          "token",
-          "dataset"
-        ],
-        "additionalProperties": false
-      },
-      "enabled": {
-        "type": "object",
-        "properties": {
-          "logs": {
-            "default": true,
-            "type": "boolean"
-          },
-          "metrics": {
-            "default": true,
-            "type": "boolean"
-          },
-          "traces": {
-            "default": true,
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "logs",
-          "metrics",
-          "traces"
-        ],
-        "additionalProperties": false
-      },
-      "export": {
-        "type": "object",
-        "properties": {
-          "flushIntervalMs": {
-            "default": 5000,
-            "type": "integer",
-            "minimum": 100,
-            "maximum": 9007199254740991
-          },
-          "maxBatchSize": {
-            "default": 1000,
-            "type": "integer",
-            "minimum": 1,
-            "maximum": 9007199254740991
-          }
-        },
-        "required": [
-          "flushIntervalMs",
-          "maxBatchSize"
-        ],
-        "additionalProperties": false
-      },
-      "resourceAttributes": {
-        "default": {},
-        "type": "object",
-        "propertyNames": {
-          "type": "string"
-        },
-        "additionalProperties": {
-          "type": "string"
-        }
-      }
-    },
-    "required": [
-      "serviceName",
-      "axiom",
-      "enabled",
-      "export",
-      "resourceAttributes"
-    ],
-    "additionalProperties": false
-  }
+  "image": "./axiom-co-logo.png"
 }

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@bsb/observable-axiom",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "description": "Axiom.co observability integration for BSB framework",
+  "type": "module",
   "main": "lib/plugins/observable-axiom/index.js",
   "types": "lib/plugins/observable-axiom/index.d.ts",
   "scripts": {
@@ -26,13 +27,14 @@
   "license": "(AGPL-3.0-only OR Commercial)",
   "author": {
     "name": "BetterCorp (PTY) Ltd",
-    "email": "nick@bettercorp.dev",
+    "email": "ninja@bettercorp.dev",
     "url": "https://bettercorp.dev/"
   },
   "peerDependencies": {
     "@bsb/base": "^9.0.0"
   },
   "dependencies": {
+    "@anyvali/js": "^0.2.0",
     "@axiomhq/js": "^1.4.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.211.0",
@@ -40,15 +42,13 @@
     "@opentelemetry/sdk-node": "^0.211.0",
     "@opentelemetry/sdk-trace-base": "^2.5.0",
     "@opentelemetry/sdk-trace-node": "^2.5.0",
-    "@opentelemetry/semantic-conventions": "^1.39.0",
-    "zod": "^4.3.6"
+    "@opentelemetry/semantic-conventions": "^1.39.0"
   },
   "devDependencies": {
-    "@bsb/base": "file:../../../nodejs",
+    "@bsb/base": "^9.0.0",
     "@types/node": "^25.2.1",
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   },
-  "homepage": "https://io.bsbcode.dev/plugins/bsb/observable-axiom"
+  "homepage": "https://io.bsbcode.dev/packages/nodejs/@bsb/observable-axiom"
 }
-

package/src/plugins/observable-axiom/index.ts

@@ -33,7 +33,7 @@ import {
   BSBError
 } from "@bsb/base";
 import { DTrace, LogMeta } from "@bsb/base";
-import { z } from "zod";
+import * as av from "@anyvali/js";
 import { Axiom } from "@axiomhq/js";
 import * as api from "@opentelemetry/api";
 import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
@@ -43,30 +43,26 @@ import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import type { IdGenerator } from "@opentelemetry/sdk-trace-base";
 
-const ConfigSchema = z.object({
-  serviceName: z.string().default("bsb-service"),
-  serviceVersion: z.string().optional(),
-
-  axiom: z.object({
-    token: z.string().describe("Axiom API token"),
-    dataset: z.string().default("bsb-logs").describe("Axiom dataset name"),
-    orgId: z.string().optional().describe("Axiom organization ID (for cloud)"),
-    url: z.url().optional().describe("Custom Axiom URL (for self-hosted)"),
-  }),
-
-  enabled: z.object({
-    logs: z.boolean().default(true),
-    metrics: z.boolean().default(true),
-    traces: z.boolean().default(true),
-  }),
-
-  export: z.object({
-    flushIntervalMs: z.number().int().min(100).default(5000),
-    maxBatchSize: z.number().int().min(1).default(1000),
-  }),
-
-  resourceAttributes: z.record(z.string(), z.string()).default({}),
-});
+const ConfigSchema = av.object({
+  serviceName: av.optional(av.string()).default("bsb-service"),
+  serviceVersion: av.optional(av.string()),
+  axiom: av.object({
+    token: av.string(),
+    dataset: av.optional(av.string()).default("bsb-logs"),
+    orgId: av.optional(av.string()),
+    url: av.optional(av.string().format("url")),
+  }, { unknownKeys: "strip" }),
+  enabled: av.object({
+    logs: av.optional(av.bool()).default(true),
+    metrics: av.optional(av.bool()).default(true),
+    traces: av.optional(av.bool()).default(true),
+  }, { unknownKeys: "strip" }),
+  export: av.object({
+    flushIntervalMs: av.optional(av.int32().min(100)).default(5000),
+    maxBatchSize: av.optional(av.int32().min(1)).default(1000),
+  }, { unknownKeys: "strip" }),
+  resourceAttributes: av.optional(av.record(av.string())).default({}),
+}, { unknownKeys: "strip" });
 
 export const Config = createConfigSchema(
   {

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "commonjs",
+    "module": "NodeNext",
     "lib": ["ES2020"],
     "declaration": true,
     "outDir": "./lib",
@@ -10,7 +10,7 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
+    "moduleResolution": "NodeNext",
     "resolveJsonModule": true,
     "types": ["node"]
   },