datanotes 1.2.1 → 1.3.0

package/SECURITY.md

@@ -47,7 +47,10 @@ Nothing leaves the machine unless you turn it on:
 - **Semantic search** sends note text to the embedding provider you configure (`semanticEnabled`,
   off by default; provider `semanticProvider` / `semanticBaseUrl`). A local provider (Ollama,
   LM Studio) keeps it on the machine.
-- **Telemetry** sends logs to the OTLP endpoint you configure (`telemetryEnabled`, off by default).
+- **Telemetry** sends logs to the OTLP endpoint you configure (`telemetryEnabled`, off by default):
+  operations, routes, note paths, actors, tool names and error messages (which may quote a value),
+  not note bodies. `telemetryHeaders` (e.g. an
+  ingestion key) is stored in the settings file; `OTEL_EXPORTER_OTLP_HEADERS` keeps it out.
 - **Webhooks** (created by the owner) post change events to the URLs they name.
 - **Apps' MCP endpoints** (registered by the owner): the engine sends each app's `mcp_token`, and
   the arguments and caller of every call of its tools, to the app's `mcp_url`, which may be remote.

package/dist/api/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   DatanotesError: () => DatanotesError,
   OPERATIONS: () => OPERATIONS,
   OperationInputError: () => OperationInputError,
+  OtlpLogExporter: () => OtlpLogExporter,
   ROUTE_PREFIX: () => ROUTE_PREFIX,
   describeBatch: () => describeBatch,
   describeRefusal: () => describeRefusal,
@@ -33,6 +34,8 @@ __export(index_exports, {
   fetchTransport: () => fetchTransport,
   operationRequest: () => operationRequest,
   operationRoute: () => operationRoute,
+  otlpFromEnv: () => otlpFromEnv,
+  parseOtlpHeaders: () => parseOtlpHeaders,
   resultOf: () => resultOf
 });
 module.exports = __toCommonJS(index_exports);
@@ -3062,6 +3065,110 @@ function estimateTokens(text) {
   return n;
 }
 
+// src/api/otlp.ts
+var SEVERITY_NUMBER = { DEBUG: 5, INFO: 9, WARN: 13, ERROR: 17 };
+function attr(key, v) {
+  if (v === void 0 || v === null) return null;
+  if (typeof v === "boolean") return { key, value: { boolValue: v } };
+  if (typeof v === "number") return Number.isInteger(v) ? { key, value: { intValue: String(v) } } : { key, value: { doubleValue: v } };
+  return { key, value: { stringValue: v } };
+}
+var attrs = (a) => Object.entries(a).map(([k, v]) => attr(k, v)).filter((x) => x !== null);
+var fetchSend = async (url, body, headers) => {
+  const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body });
+  if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
+};
+var OtlpLogExporter = class {
+  constructor(o) {
+    this.o = o;
+    this.buffer = [];
+    this.inflight = Promise.resolve();
+    this.timer = null;
+    /** Records sent, and records lost because the collector did not take them. */
+    this.sent = 0;
+    this.dropped = 0;
+    const every = o.flushMs ?? 5e3;
+    if (every > 0) {
+      this.timer = setInterval(() => void this.flush(), every);
+      this.timer.unref?.();
+    }
+  }
+  log(severity, body, attributes = {}) {
+    const ms = (this.o.now ?? Date.now)();
+    this.buffer.push({ timeUnixNano: `${Math.round(ms)}000000`, severity, body, attributes });
+    if (this.buffer.length >= (this.o.maxBatch ?? 50)) void this.flush();
+  }
+  /** Send what is buffered. Never rejects. */
+  flush() {
+    if (this.buffer.length === 0) return this.inflight;
+    const batch = this.buffer;
+    this.buffer = [];
+    const body = JSON.stringify({
+      resourceLogs: [
+        {
+          resource: { attributes: attrs({ "service.name": this.o.serviceName, "service.version": this.o.serviceVersion, ...this.o.resource }) },
+          scopeLogs: [
+            {
+              scope: { name: this.o.serviceName },
+              logRecords: batch.map((r) => ({
+                timeUnixNano: r.timeUnixNano,
+                observedTimeUnixNano: r.timeUnixNano,
+                severityNumber: SEVERITY_NUMBER[r.severity],
+                severityText: r.severity,
+                body: { stringValue: r.body },
+                attributes: attrs(r.attributes)
+              }))
+            }
+          ]
+        }
+      ]
+    });
+    const url = `${this.o.endpoint.replace(/\/+$/, "")}/v1/logs`;
+    const send = this.o.send ?? fetchSend;
+    this.inflight = this.inflight.then(
+      () => send(url, body, this.o.headers ?? {}).then(
+        () => void (this.sent += batch.length),
+        () => void (this.dropped += batch.length)
+      )
+    );
+    return this.inflight;
+  }
+  /** Stop the timer and send what is left. */
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.flush();
+  }
+};
+function parseOtlpHeaders(text) {
+  const out = {};
+  for (const part of (text ?? "").split(",")) {
+    const i = part.indexOf("=");
+    if (i <= 0) continue;
+    const key = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (!key) continue;
+    try {
+      out[key] = decodeURIComponent(value);
+    } catch {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function otlpFromEnv(env, defaults) {
+  const logs = env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT?.trim();
+  const base = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+  const endpoint = logs ? logs.replace(/\/v1\/logs\/?$/, "") : base;
+  if (!endpoint) return null;
+  return {
+    endpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || defaults.serviceName,
+    ...defaults.serviceVersion ? { serviceVersion: defaults.serviceVersion } : {},
+    headers: { ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_LOGS_HEADERS) }
+  };
+}
+
 // src/api/client.ts
 var ACTOR_HEADER = "X-Datanotes-Actor";
 var DatanotesError = class extends Error {

package/dist/api/index.d.ts

@@ -6,4 +6,5 @@ export { OPERATIONS, type OperationDef } from "./catalog";
 export { operationRequest, operationRoute, CALLABLE_OPERATIONS, OperationInputError, ROUTE_PREFIX, type OperationRequest } from "./requests";
 export { resultOf, describeRefusal, describeBatch, type OperationResult } from "./results";
 export { estimateTokens } from "./tokens";
+export { OtlpLogExporter, otlpFromEnv, parseOtlpHeaders, type OtlpOptions, type Severity, type AttrValue } from "./otlp";
 export { DatanotesClient, DatanotesError, fetchTransport, ACTOR_HEADER, type ActorInfo, type AppTool, type ClientOptions, type HttpRequest, type HttpResponse, type ToolCallRecord, type Transport, } from "./client";

package/dist/api/index.js

@@ -3023,6 +3023,110 @@ function estimateTokens(text) {
   return n;
 }
 
+// src/api/otlp.ts
+var SEVERITY_NUMBER = { DEBUG: 5, INFO: 9, WARN: 13, ERROR: 17 };
+function attr(key, v) {
+  if (v === void 0 || v === null) return null;
+  if (typeof v === "boolean") return { key, value: { boolValue: v } };
+  if (typeof v === "number") return Number.isInteger(v) ? { key, value: { intValue: String(v) } } : { key, value: { doubleValue: v } };
+  return { key, value: { stringValue: v } };
+}
+var attrs = (a) => Object.entries(a).map(([k, v]) => attr(k, v)).filter((x) => x !== null);
+var fetchSend = async (url, body, headers) => {
+  const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body });
+  if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
+};
+var OtlpLogExporter = class {
+  constructor(o) {
+    this.o = o;
+    this.buffer = [];
+    this.inflight = Promise.resolve();
+    this.timer = null;
+    /** Records sent, and records lost because the collector did not take them. */
+    this.sent = 0;
+    this.dropped = 0;
+    const every = o.flushMs ?? 5e3;
+    if (every > 0) {
+      this.timer = setInterval(() => void this.flush(), every);
+      this.timer.unref?.();
+    }
+  }
+  log(severity, body, attributes = {}) {
+    const ms = (this.o.now ?? Date.now)();
+    this.buffer.push({ timeUnixNano: `${Math.round(ms)}000000`, severity, body, attributes });
+    if (this.buffer.length >= (this.o.maxBatch ?? 50)) void this.flush();
+  }
+  /** Send what is buffered. Never rejects. */
+  flush() {
+    if (this.buffer.length === 0) return this.inflight;
+    const batch = this.buffer;
+    this.buffer = [];
+    const body = JSON.stringify({
+      resourceLogs: [
+        {
+          resource: { attributes: attrs({ "service.name": this.o.serviceName, "service.version": this.o.serviceVersion, ...this.o.resource }) },
+          scopeLogs: [
+            {
+              scope: { name: this.o.serviceName },
+              logRecords: batch.map((r) => ({
+                timeUnixNano: r.timeUnixNano,
+                observedTimeUnixNano: r.timeUnixNano,
+                severityNumber: SEVERITY_NUMBER[r.severity],
+                severityText: r.severity,
+                body: { stringValue: r.body },
+                attributes: attrs(r.attributes)
+              }))
+            }
+          ]
+        }
+      ]
+    });
+    const url = `${this.o.endpoint.replace(/\/+$/, "")}/v1/logs`;
+    const send = this.o.send ?? fetchSend;
+    this.inflight = this.inflight.then(
+      () => send(url, body, this.o.headers ?? {}).then(
+        () => void (this.sent += batch.length),
+        () => void (this.dropped += batch.length)
+      )
+    );
+    return this.inflight;
+  }
+  /** Stop the timer and send what is left. */
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.flush();
+  }
+};
+function parseOtlpHeaders(text) {
+  const out = {};
+  for (const part of (text ?? "").split(",")) {
+    const i = part.indexOf("=");
+    if (i <= 0) continue;
+    const key = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (!key) continue;
+    try {
+      out[key] = decodeURIComponent(value);
+    } catch {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function otlpFromEnv(env, defaults) {
+  const logs = env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT?.trim();
+  const base = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+  const endpoint = logs ? logs.replace(/\/v1\/logs\/?$/, "") : base;
+  if (!endpoint) return null;
+  return {
+    endpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || defaults.serviceName,
+    ...defaults.serviceVersion ? { serviceVersion: defaults.serviceVersion } : {},
+    headers: { ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_LOGS_HEADERS) }
+  };
+}
+
 // src/api/client.ts
 var ACTOR_HEADER = "X-Datanotes-Actor";
 var DatanotesError = class extends Error {
@@ -3130,6 +3234,7 @@ export {
   DatanotesError,
   OPERATIONS,
   OperationInputError,
+  OtlpLogExporter,
   ROUTE_PREFIX,
   describeBatch,
   describeRefusal,
@@ -3137,5 +3242,7 @@ export {
   fetchTransport,
   operationRequest,
   operationRoute,
+  otlpFromEnv,
+  parseOtlpHeaders,
   resultOf
 };

package/dist/api/otlp.d.ts

@@ -0,0 +1,54 @@
+/**
+ * OTLP/HTTP log export for programs around the engine (MCP servers, apps): records are buffered
+ * and POSTed as OTLP JSON to `<endpoint>/v1/logs`, the format SigNoz and any OpenTelemetry
+ * collector read. No dependency, no SDK. Export failures are counted, never thrown: logging must
+ * not break the program.
+ *
+ * Configure it in code, or from the standard environment variables with `otlpFromEnv`.
+ */
+export type Severity = "DEBUG" | "INFO" | "WARN" | "ERROR";
+export type AttrValue = string | number | boolean | null | undefined;
+export interface OtlpOptions {
+    /** Collector base URL, e.g. `http://127.0.0.1:4318` (`/v1/logs` is added). */
+    endpoint: string;
+    /** `service.name` of the records. */
+    serviceName: string;
+    serviceVersion?: string;
+    /** Extra headers, e.g. `{"signoz-ingestion-key": "…"}`. */
+    headers?: Record<string, string>;
+    /** More resource attributes (e.g. `host.name`). */
+    resource?: Record<string, AttrValue>;
+    /** Send at most this many records per request (default 50); a full buffer is sent at once. */
+    maxBatch?: number;
+    /** Send the buffer every this many ms (default 5000; 0: only on `flush`). */
+    flushMs?: number;
+    /** POST a body; resolves on 2xx (default: fetch). */
+    send?: (url: string, body: string, headers: Record<string, string>) => Promise<void>;
+    now?: () => number;
+}
+export declare class OtlpLogExporter {
+    private readonly o;
+    private buffer;
+    private inflight;
+    private timer;
+    /** Records sent, and records lost because the collector did not take them. */
+    sent: number;
+    dropped: number;
+    constructor(o: OtlpOptions);
+    log(severity: Severity, body: string, attributes?: Record<string, AttrValue>): void;
+    /** Send what is buffered. Never rejects. */
+    flush(): Promise<void>;
+    /** Stop the timer and send what is left. */
+    close(): Promise<void>;
+}
+/** `k1=v1,k2=v2` (values URL-encoded), the format of `OTEL_EXPORTER_OTLP_HEADERS`. */
+export declare function parseOtlpHeaders(text: string | undefined): Record<string, string>;
+/**
+ * Exporter options from the standard OpenTelemetry variables, or null when no endpoint is set:
+ * `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` (full URL of /v1/logs) or `OTEL_EXPORTER_OTLP_ENDPOINT`,
+ * `OTEL_EXPORTER_OTLP_HEADERS` / `OTEL_EXPORTER_OTLP_LOGS_HEADERS`, `OTEL_SERVICE_NAME`.
+ */
+export declare function otlpFromEnv(env: Record<string, string | undefined>, defaults: {
+    serviceName: string;
+    serviceVersion?: string;
+}): OtlpOptions | null;

package/dist/datanotes.cjs

@@ -7425,6 +7425,7 @@ var DEFAULT_SETTINGS = {
   telemetryEnabled: false,
   telemetryEndpoint: "http://127.0.0.1:4318",
   telemetryServiceName: "datanotes",
+  telemetryHeaders: {},
   autoRecompute: true,
   viewNotes: true,
   semanticEnabled: false,
@@ -7450,6 +7451,7 @@ var KEYS = [
   "telemetryEnabled",
   "telemetryEndpoint",
   "telemetryServiceName",
+  "telemetryHeaders",
   "autoRecompute",
   "viewNotes",
   "semanticEnabled",
@@ -7500,6 +7502,14 @@ function mergeWithDefaults(loaded) {
         }
         break;
       }
+      case "telemetryHeaders": {
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+          out.telemetryHeaders = Object.fromEntries(
+            Object.entries(raw).filter(([k, v]) => /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/.test(k) && typeof v === "string")
+          );
+        }
+        break;
+      }
       case "telemetryServiceName": {
         if (typeof raw === "string" && raw.trim().length > 0) {
           out.telemetryServiceName = raw.trim();
@@ -7659,7 +7669,7 @@ function otlpLogsPayload(serviceName, records, resource = {}) {
         resource: { attributes: attrs({ "service.name": serviceName, ...resource }) },
         scopeLogs: [
           {
-            scope: { name: "obsidian-datanotes" },
+            scope: { name: "datanotes" },
             logRecords: records.map((r) => ({
               timeUnixNano: r.timeUnixNano,
               observedTimeUnixNano: r.timeUnixNano,
@@ -7705,7 +7715,7 @@ var OtlpLogger = class {
     const url = `${settings.telemetryEndpoint.replace(/\/+$/, "")}/v1/logs`;
     const body = otlpLogsPayload(settings.telemetryServiceName, batch, this.opts.resource);
     this.inflight = this.inflight.then(
-      () => this.opts.transport(url, body).then(
+      () => this.opts.transport(url, body, { ...settings.telemetryHeaders ?? {} }).then(
         () => {
           this.sent += batch.length;
         },
@@ -7840,6 +7850,24 @@ var LockHolder = class {
   }
 };
 
+// src/api/otlp.ts
+function parseOtlpHeaders(text2) {
+  const out = {};
+  for (const part of (text2 ?? "").split(",")) {
+    const i = part.indexOf("=");
+    if (i <= 0) continue;
+    const key = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (!key) continue;
+    try {
+      out[key] = decodeURIComponent(value);
+    } catch {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
 // src/core/filename-values.ts
 var PLACEHOLDER = /\{([A-Za-z][A-Za-z0-9_-]*)(?::([^}]+))?\}/g;
 var FORMAT_TOKEN = /\[([^\]]*)\]|YYYY|MM|DD|HH|mm|ss/g;
@@ -20762,7 +20790,7 @@ var EngineRuntime = class {
     const s = this.o.getSettings;
     const logger = new OtlpLogger({
       getSettings: s,
-      transport: async (url, body) => this.o.postLogs(url, body),
+      transport: async (url, body, headers) => this.o.postLogs(url, body, headers),
       resource: { "service.version": this.o.version, "host.name": this.o.hostName }
     });
     const source = this.o.hostName;
@@ -22069,7 +22097,7 @@ var NodeWatcher = class {
 };
 
 // src/node/service.ts
-var VERSION = true ? "1.2.1" : "dev";
+var VERSION = true ? "1.3.0" : "dev";
 function parseArgs(argv, env = process.env) {
   const get = (name) => {
     const i = argv.indexOf(`--${name}`);
@@ -22137,8 +22165,9 @@ async function startService(o, env = process.env) {
       const res = await fetch(req.url, { method: req.method, headers: req.headers, body: req.body });
       return { status: res.status, text: await res.text() };
     },
-    postLogs: async (url, body) => {
-      const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body });
+    postLogs: async (url, body, headers) => {
+      const all = { ...headers, ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS) };
+      const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...all }, body });
       if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
     },
     embeddingKey: () => env.DATANOTES_EMBEDDING_KEY || keyFromFile(),
@@ -22247,7 +22276,7 @@ Docs: https://datanotes.dev`;
 }
 
 // src/node/cli.ts
-var VERSION2 = true ? "1.2.1" : "dev";
+var VERSION2 = true ? "1.3.0" : "dev";
 async function main2(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;
   if (command === "--version" || command === "-v" || command === "version") return void process.stdout.write(`${VERSION2}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datanotes",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "The engine of your second brain: Markdown notes as database tables, for you and your agents.",
   "keywords": [
     "markdown",