datanotes 1.2.1 → 1.4.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` (an API 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,197 @@ 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, body });
+  if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
+};
+var Pb = class {
+  constructor() {
+    this.parts = [];
+  }
+  varint(v) {
+    let x = BigInt.asUintN(64, v);
+    const b128 = BigInt(128);
+    const low7 = BigInt(127);
+    const seven = BigInt(7);
+    while (x >= b128) {
+      this.parts.push(Number(x & low7) | 128);
+      x >>= seven;
+    }
+    this.parts.push(Number(x));
+  }
+  tag(field, wire) {
+    this.varint(BigInt(field << 3 | wire));
+  }
+  uint(field, v) {
+    this.tag(field, 0);
+    this.varint(BigInt(v));
+    return this;
+  }
+  fixed64(field, v) {
+    this.tag(field, 1);
+    for (let i = 0; i < 8; i++) this.parts.push(Number(v >> BigInt(8 * i) & BigInt(255)));
+    return this;
+  }
+  double(field, v) {
+    this.tag(field, 1);
+    const b = new DataView(new ArrayBuffer(8));
+    b.setFloat64(0, v, true);
+    for (let i = 0; i < 8; i++) this.parts.push(b.getUint8(i));
+    return this;
+  }
+  bytes(field, data) {
+    this.tag(field, 2);
+    this.varint(BigInt(data.length));
+    for (const x of data) this.parts.push(x);
+    return this;
+  }
+  string(field, s) {
+    return this.bytes(field, new TextEncoder().encode(s));
+  }
+  message(field, m) {
+    return this.bytes(field, m.finish());
+  }
+  finish() {
+    return Uint8Array.from(this.parts);
+  }
+};
+function pbValue(v) {
+  if (typeof v === "string") return new Pb().string(1, v);
+  if (typeof v === "boolean") return new Pb().uint(2, v ? 1 : 0);
+  return Number.isInteger(v) ? new Pb().uint(3, BigInt(v)) : new Pb().double(4, v);
+}
+function pbAttrs(m, field, a) {
+  for (const [k, v] of Object.entries(a)) {
+    if (v === void 0 || v === null) continue;
+    m.message(field, new Pb().string(1, k).message(2, pbValue(v)));
+  }
+  return m;
+}
+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 resource = { "service.name": this.o.serviceName, "service.version": this.o.serviceVersion, ...this.o.resource };
+    const protobuf = (this.o.protocol ?? "http/protobuf") === "http/protobuf";
+    const body = protobuf ? this.protobuf(resource, batch) : JSON.stringify({
+      resourceLogs: [
+        {
+          resource: { attributes: attrs(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, { "Content-Type": protobuf ? "application/x-protobuf" : "application/json", ...this.o.headers ?? {} }).then(
+        () => void (this.sent += batch.length),
+        () => void (this.dropped += batch.length)
+      )
+    );
+    return this.inflight;
+  }
+  protobuf(resource, batch) {
+    const scope = new Pb().message(1, new Pb().string(1, this.o.serviceName));
+    for (const r of batch) {
+      const t = BigInt(r.timeUnixNano);
+      const rec = new Pb().fixed64(1, t).uint(2, SEVERITY_NUMBER[r.severity]).string(3, r.severity).message(5, new Pb().string(1, r.body));
+      pbAttrs(rec, 6, r.attributes).fixed64(11, t);
+      scope.message(2, rec);
+    }
+    const resourceLogs = new Pb().message(1, pbAttrs(new Pb(), 1, resource)).message(2, scope);
+    return new Pb().message(1, resourceLogs).finish();
+  }
+  /** 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;
+}
+var parseResourceAttributes = parseOtlpHeaders;
+var truthy = (v) => (v ?? "").trim().toLowerCase() === "true";
+function otlpFromEnv(env, defaults) {
+  if (truthy(env.OTEL_SDK_DISABLED) || (env.OTEL_LOGS_EXPORTER ?? "").trim().toLowerCase() === "none") return null;
+  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;
+  const protocol = otlpProtocol(env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL);
+  const resource = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+  return {
+    endpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || resource["service.name"] || defaults.serviceName,
+    ...defaults.serviceVersion ? { serviceVersion: defaults.serviceVersion } : {},
+    ...protocol ? { protocol } : {},
+    ...Object.keys(resource).length ? { resource } : {},
+    headers: { ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_LOGS_HEADERS) }
+  };
+}
+function otlpProtocol(v) {
+  const p = (v ?? "").trim().toLowerCase();
+  return p === "http/protobuf" || p === "http/json" ? p : void 0;
+}
+
 // 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,197 @@ 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, body });
+  if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
+};
+var Pb = class {
+  constructor() {
+    this.parts = [];
+  }
+  varint(v) {
+    let x = BigInt.asUintN(64, v);
+    const b128 = BigInt(128);
+    const low7 = BigInt(127);
+    const seven = BigInt(7);
+    while (x >= b128) {
+      this.parts.push(Number(x & low7) | 128);
+      x >>= seven;
+    }
+    this.parts.push(Number(x));
+  }
+  tag(field, wire) {
+    this.varint(BigInt(field << 3 | wire));
+  }
+  uint(field, v) {
+    this.tag(field, 0);
+    this.varint(BigInt(v));
+    return this;
+  }
+  fixed64(field, v) {
+    this.tag(field, 1);
+    for (let i = 0; i < 8; i++) this.parts.push(Number(v >> BigInt(8 * i) & BigInt(255)));
+    return this;
+  }
+  double(field, v) {
+    this.tag(field, 1);
+    const b = new DataView(new ArrayBuffer(8));
+    b.setFloat64(0, v, true);
+    for (let i = 0; i < 8; i++) this.parts.push(b.getUint8(i));
+    return this;
+  }
+  bytes(field, data) {
+    this.tag(field, 2);
+    this.varint(BigInt(data.length));
+    for (const x of data) this.parts.push(x);
+    return this;
+  }
+  string(field, s) {
+    return this.bytes(field, new TextEncoder().encode(s));
+  }
+  message(field, m) {
+    return this.bytes(field, m.finish());
+  }
+  finish() {
+    return Uint8Array.from(this.parts);
+  }
+};
+function pbValue(v) {
+  if (typeof v === "string") return new Pb().string(1, v);
+  if (typeof v === "boolean") return new Pb().uint(2, v ? 1 : 0);
+  return Number.isInteger(v) ? new Pb().uint(3, BigInt(v)) : new Pb().double(4, v);
+}
+function pbAttrs(m, field, a) {
+  for (const [k, v] of Object.entries(a)) {
+    if (v === void 0 || v === null) continue;
+    m.message(field, new Pb().string(1, k).message(2, pbValue(v)));
+  }
+  return m;
+}
+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 resource = { "service.name": this.o.serviceName, "service.version": this.o.serviceVersion, ...this.o.resource };
+    const protobuf = (this.o.protocol ?? "http/protobuf") === "http/protobuf";
+    const body = protobuf ? this.protobuf(resource, batch) : JSON.stringify({
+      resourceLogs: [
+        {
+          resource: { attributes: attrs(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, { "Content-Type": protobuf ? "application/x-protobuf" : "application/json", ...this.o.headers ?? {} }).then(
+        () => void (this.sent += batch.length),
+        () => void (this.dropped += batch.length)
+      )
+    );
+    return this.inflight;
+  }
+  protobuf(resource, batch) {
+    const scope = new Pb().message(1, new Pb().string(1, this.o.serviceName));
+    for (const r of batch) {
+      const t = BigInt(r.timeUnixNano);
+      const rec = new Pb().fixed64(1, t).uint(2, SEVERITY_NUMBER[r.severity]).string(3, r.severity).message(5, new Pb().string(1, r.body));
+      pbAttrs(rec, 6, r.attributes).fixed64(11, t);
+      scope.message(2, rec);
+    }
+    const resourceLogs = new Pb().message(1, pbAttrs(new Pb(), 1, resource)).message(2, scope);
+    return new Pb().message(1, resourceLogs).finish();
+  }
+  /** 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;
+}
+var parseResourceAttributes = parseOtlpHeaders;
+var truthy = (v) => (v ?? "").trim().toLowerCase() === "true";
+function otlpFromEnv(env, defaults) {
+  if (truthy(env.OTEL_SDK_DISABLED) || (env.OTEL_LOGS_EXPORTER ?? "").trim().toLowerCase() === "none") return null;
+  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;
+  const protocol = otlpProtocol(env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL);
+  const resource = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+  return {
+    endpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || resource["service.name"] || defaults.serviceName,
+    ...defaults.serviceVersion ? { serviceVersion: defaults.serviceVersion } : {},
+    ...protocol ? { protocol } : {},
+    ...Object.keys(resource).length ? { resource } : {},
+    headers: { ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_LOGS_HEADERS) }
+  };
+}
+function otlpProtocol(v) {
+  const p = (v ?? "").trim().toLowerCase();
+  return p === "http/protobuf" || p === "http/json" ? p : void 0;
+}
+
 // src/api/client.ts
 var ACTOR_HEADER = "X-Datanotes-Actor";
 var DatanotesError = class extends Error {
@@ -3130,6 +3321,7 @@ export {
   DatanotesError,
   OPERATIONS,
   OperationInputError,
+  OtlpLogExporter,
   ROUTE_PREFIX,
   describeBatch,
   describeRefusal,
@@ -3137,5 +3329,7 @@ export {
   fetchTransport,
   operationRequest,
   operationRoute,
+  otlpFromEnv,
+  parseOtlpHeaders,
   resultOf
 };

package/dist/api/otlp.d.ts

@@ -0,0 +1,65 @@
+/**
+ * OpenTelemetry log export over OTLP/HTTP, vendor-neutral: records are buffered and POSTed to
+ * `<endpoint>/v1/logs` as `http/protobuf` (the OTLP default) or `http/json`, which every
+ * OpenTelemetry collector and OTLP backend reads. No dependency, no SDK. Export failures are
+ * counted, never thrown: logging must not break the program. (OTLP over gRPC is not supported:
+ * use the collector's HTTP port, 4318 by default.)
+ *
+ * Configure it in code, or from the standard OpenTelemetry variables with `otlpFromEnv`.
+ */
+export type Severity = "DEBUG" | "INFO" | "WARN" | "ERROR";
+export type AttrValue = string | number | boolean | null | undefined;
+export type OtlpProtocol = "http/protobuf" | "http/json";
+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;
+    /** `http/protobuf` (default) or `http/json`. */
+    protocol?: OtlpProtocol;
+    /** Extra headers, e.g. an API key or `Authorization`, as the backend asks. */
+    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). `headers` include the Content-Type. */
+    send?: (url: string, body: string | Uint8Array, 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>;
+    private protobuf;
+    /** 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>;
+/** `k1=v1,k2=v2` resource attributes, the format of `OTEL_RESOURCE_ATTRIBUTES`. */
+export declare const parseResourceAttributes: typeof parseOtlpHeaders;
+/**
+ * Exporter options from the standard OpenTelemetry variables, or null when export is off (no
+ * endpoint, `OTEL_SDK_DISABLED=true` or `OTEL_LOGS_EXPORTER=none`):
+ * `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` (full URL of /v1/logs) or `OTEL_EXPORTER_OTLP_ENDPOINT`;
+ * `OTEL_EXPORTER_OTLP_[LOGS_]HEADERS`; `OTEL_EXPORTER_OTLP_[LOGS_]PROTOCOL` (`http/protobuf`,
+ * `http/json`); `OTEL_SERVICE_NAME`; `OTEL_RESOURCE_ATTRIBUTES`.
+ */
+export declare function otlpFromEnv(env: Record<string, string | undefined>, defaults: {
+    serviceName: string;
+    serviceVersion?: string;
+}): OtlpOptions | null;
+/** `http/protobuf` or `http/json` from a setting or variable; undefined for anything else. */
+export declare function otlpProtocol(v: string | undefined): OtlpProtocol | undefined;

package/dist/datanotes.cjs

@@ -7425,6 +7425,8 @@ var DEFAULT_SETTINGS = {
   telemetryEnabled: false,
   telemetryEndpoint: "http://127.0.0.1:4318",
   telemetryServiceName: "datanotes",
+  telemetryHeaders: {},
+  telemetryProtocol: "http/protobuf",
   autoRecompute: true,
   viewNotes: true,
   semanticEnabled: false,
@@ -7450,6 +7452,8 @@ var KEYS = [
   "telemetryEnabled",
   "telemetryEndpoint",
   "telemetryServiceName",
+  "telemetryHeaders",
+  "telemetryProtocol",
   "autoRecompute",
   "viewNotes",
   "semanticEnabled",
@@ -7500,6 +7504,18 @@ function mergeWithDefaults(loaded) {
         }
         break;
       }
+      case "telemetryProtocol": {
+        if (raw === "http/protobuf" || raw === "http/json") out.telemetryProtocol = raw;
+        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();
@@ -7634,89 +7650,12 @@ async function storeRename(app, from, to) {
 }
 
 // src/core/telemetry.ts
-var SEVERITY_NUMBER = { DEBUG: 5, INFO: 9, WARN: 13, ERROR: 17 };
 var NOOP_TELEMETRY = {
   log: () => {
   },
   flush: async () => {
   }
 };
-function otlpAttr(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 } };
-}
-function attrs(a) {
-  return Object.entries(a).map(([k, v]) => otlpAttr(k, v)).filter((x) => x != null);
-}
-function otlpLogsPayload(serviceName, records, resource = {}) {
-  return JSON.stringify({
-    resourceLogs: [
-      {
-        resource: { attributes: attrs({ "service.name": serviceName, ...resource }) },
-        scopeLogs: [
-          {
-            scope: { name: "obsidian-datanotes" },
-            logRecords: records.map((r) => ({
-              timeUnixNano: r.timeUnixNano,
-              observedTimeUnixNano: r.timeUnixNano,
-              severityNumber: SEVERITY_NUMBER[r.severity],
-              severityText: r.severity,
-              body: { stringValue: r.body },
-              attributes: attrs(r.attributes)
-            }))
-          }
-        ]
-      }
-    ]
-  });
-}
-var OtlpLogger = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.buffer = [];
-    this.inflight = Promise.resolve();
-    this.dropped = 0;
-    this.sent = 0;
-  }
-  log(severity, body, attributes = {}) {
-    if (!this.opts.getSettings().telemetryEnabled) return;
-    const ms = (this.opts.now ?? Date.now)();
-    this.buffer.push({
-      timeUnixNano: `${Math.round(ms)}000000`,
-      severity,
-      body,
-      attributes
-    });
-    if (this.buffer.length >= (this.opts.maxBatch ?? 50)) void this.flush();
-  }
-  /** Send buffered records. Never rejects. */
-  flush() {
-    const settings = this.opts.getSettings();
-    if (!settings.telemetryEnabled || this.buffer.length === 0) {
-      this.buffer = [];
-      return this.inflight;
-    }
-    const batch = this.buffer;
-    this.buffer = [];
-    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.sent += batch.length;
-        },
-        () => {
-          this.dropped += batch.length;
-        }
-      )
-    );
-    return this.inflight;
-  }
-};
 var current = NOOP_TELEMETRY;
 function setTelemetry(t) {
   current = t;
@@ -15250,6 +15189,246 @@ var SemanticIndex = class {
   }
 };
 
+// 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, body });
+  if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
+};
+var Pb = class {
+  constructor() {
+    this.parts = [];
+  }
+  varint(v) {
+    let x = BigInt.asUintN(64, v);
+    const b128 = BigInt(128);
+    const low7 = BigInt(127);
+    const seven = BigInt(7);
+    while (x >= b128) {
+      this.parts.push(Number(x & low7) | 128);
+      x >>= seven;
+    }
+    this.parts.push(Number(x));
+  }
+  tag(field, wire) {
+    this.varint(BigInt(field << 3 | wire));
+  }
+  uint(field, v) {
+    this.tag(field, 0);
+    this.varint(BigInt(v));
+    return this;
+  }
+  fixed64(field, v) {
+    this.tag(field, 1);
+    for (let i = 0; i < 8; i++) this.parts.push(Number(v >> BigInt(8 * i) & BigInt(255)));
+    return this;
+  }
+  double(field, v) {
+    this.tag(field, 1);
+    const b = new DataView(new ArrayBuffer(8));
+    b.setFloat64(0, v, true);
+    for (let i = 0; i < 8; i++) this.parts.push(b.getUint8(i));
+    return this;
+  }
+  bytes(field, data) {
+    this.tag(field, 2);
+    this.varint(BigInt(data.length));
+    for (const x of data) this.parts.push(x);
+    return this;
+  }
+  string(field, s) {
+    return this.bytes(field, new TextEncoder().encode(s));
+  }
+  message(field, m) {
+    return this.bytes(field, m.finish());
+  }
+  finish() {
+    return Uint8Array.from(this.parts);
+  }
+};
+function pbValue(v) {
+  if (typeof v === "string") return new Pb().string(1, v);
+  if (typeof v === "boolean") return new Pb().uint(2, v ? 1 : 0);
+  return Number.isInteger(v) ? new Pb().uint(3, BigInt(v)) : new Pb().double(4, v);
+}
+function pbAttrs(m, field, a) {
+  for (const [k, v] of Object.entries(a)) {
+    if (v === void 0 || v === null) continue;
+    m.message(field, new Pb().string(1, k).message(2, pbValue(v)));
+  }
+  return m;
+}
+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 resource = { "service.name": this.o.serviceName, "service.version": this.o.serviceVersion, ...this.o.resource };
+    const protobuf = (this.o.protocol ?? "http/protobuf") === "http/protobuf";
+    const body = protobuf ? this.protobuf(resource, batch) : JSON.stringify({
+      resourceLogs: [
+        {
+          resource: { attributes: attrs(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 send2 = this.o.send ?? fetchSend;
+    this.inflight = this.inflight.then(
+      () => send2(url, body, { "Content-Type": protobuf ? "application/x-protobuf" : "application/json", ...this.o.headers ?? {} }).then(
+        () => void (this.sent += batch.length),
+        () => void (this.dropped += batch.length)
+      )
+    );
+    return this.inflight;
+  }
+  protobuf(resource, batch) {
+    const scope = new Pb().message(1, new Pb().string(1, this.o.serviceName));
+    for (const r of batch) {
+      const t = BigInt(r.timeUnixNano);
+      const rec = new Pb().fixed64(1, t).uint(2, SEVERITY_NUMBER[r.severity]).string(3, r.severity).message(5, new Pb().string(1, r.body));
+      pbAttrs(rec, 6, r.attributes).fixed64(11, t);
+      scope.message(2, rec);
+    }
+    const resourceLogs = new Pb().message(1, pbAttrs(new Pb(), 1, resource)).message(2, scope);
+    return new Pb().message(1, resourceLogs).finish();
+  }
+  /** Stop the timer and send what is left. */
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.flush();
+  }
+};
+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;
+}
+var parseResourceAttributes = parseOtlpHeaders;
+var truthy = (v) => (v ?? "").trim().toLowerCase() === "true";
+function otlpFromEnv(env, defaults) {
+  if (truthy(env.OTEL_SDK_DISABLED) || (env.OTEL_LOGS_EXPORTER ?? "").trim().toLowerCase() === "none") return null;
+  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;
+  const protocol = otlpProtocol(env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL);
+  const resource = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+  return {
+    endpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || resource["service.name"] || defaults.serviceName,
+    ...defaults.serviceVersion ? { serviceVersion: defaults.serviceVersion } : {},
+    ...protocol ? { protocol } : {},
+    ...Object.keys(resource).length ? { resource } : {},
+    headers: { ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_LOGS_HEADERS) }
+  };
+}
+function otlpProtocol(v) {
+  const p = (v ?? "").trim().toLowerCase();
+  return p === "http/protobuf" || p === "http/json" ? p : void 0;
+}
+
+// src/server/otlp-sink.ts
+function resolveOtlp(s, env, base) {
+  const fromEnv = otlpFromEnv(env, { serviceName: s.telemetryServiceName, serviceVersion: base.serviceVersion });
+  const disabled = (env.OTEL_SDK_DISABLED ?? "").trim().toLowerCase() === "true" || (env.OTEL_LOGS_EXPORTER ?? "").trim().toLowerCase() === "none";
+  if (disabled || !fromEnv && !s.telemetryEnabled) return null;
+  const resource = { ...base.resource, ...parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES) };
+  const envProtocol = otlpProtocol(env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL);
+  return {
+    endpoint: fromEnv?.endpoint ?? s.telemetryEndpoint,
+    serviceName: env.OTEL_SERVICE_NAME?.trim() || s.telemetryServiceName,
+    serviceVersion: base.serviceVersion,
+    protocol: envProtocol ?? s.telemetryProtocol ?? "http/protobuf",
+    headers: { ...s.telemetryHeaders ?? {}, ...fromEnv?.headers ?? {} },
+    resource
+  };
+}
+var OtlpSink = class {
+  constructor(options, send2) {
+    this.options = options;
+    this.send = send2;
+    this.exporter = null;
+    this.key = "";
+  }
+  /** The exporter for the current options (a new one when they changed), or null. */
+  current() {
+    const o = this.options();
+    const key = o ? JSON.stringify(o) : "";
+    if (key !== this.key) {
+      const old = this.exporter;
+      void old?.close();
+      this.exporter = o ? new OtlpLogExporter({ ...o, flushMs: 0, ...this.send ? { send: this.send } : {} }) : null;
+      this.key = key;
+    }
+    return this.exporter;
+  }
+  log(severity, body, attributes) {
+    this.current()?.log(severity, body, attributes);
+  }
+  async flush() {
+    await this.current()?.flush();
+  }
+  get sent() {
+    return this.exporter?.sent ?? 0;
+  }
+  get dropped() {
+    return this.exporter?.dropped ?? 0;
+  }
+};
+
 // src/core/view-block.ts
 var import_yaml3 = __toESM(require_dist(), 1);
 var BLOCK_KEYS = /* @__PURE__ */ new Set(["view", "table", "columns", "where", "order_by", "limit", "join", "group_by", "aggregates", "expand", "labels", "row_link", "chart", "with_table"]);
@@ -20757,14 +20936,10 @@ var EngineRuntime = class {
       session: call.session ?? ""
     });
   }
-  /** Logs to the OTLP collector (when enabled) and to `.datanotes/logs/`. */
+  /** Logs to an OpenTelemetry collector (when configured) and to `.datanotes/logs/`. */
   startTelemetry() {
     const s = this.o.getSettings;
-    const logger = new OtlpLogger({
-      getSettings: s,
-      transport: async (url, body) => this.o.postLogs(url, body),
-      resource: { "service.version": this.o.version, "host.name": this.o.hostName }
-    });
+    const logger = new OtlpSink(() => resolveOtlp(s(), this.o.env ?? {}, { serviceVersion: this.o.version, resource: { "service.instance.id": this.o.hostName } }), this.o.otlpSend);
     const source = this.o.hostName;
     const fileLog = new FileLogger({ enabled: () => s().fileLogEnabled, write: (day, lines) => appendLog(this.o.app, s(), day, lines, source) });
     const tee = new TeeTelemetry([logger, fileLog]);
@@ -22069,7 +22244,7 @@ var NodeWatcher = class {
 };
 
 // src/node/service.ts
-var VERSION = true ? "1.2.1" : "dev";
+var VERSION = true ? "1.4.0" : "dev";
 function parseArgs(argv, env = process.env) {
   const get = (name) => {
     const i = argv.indexOf(`--${name}`);
@@ -22137,10 +22312,7 @@ 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 });
-      if (!res.ok) throw new Error(`OTLP HTTP ${res.status}`);
-    },
+    env,
     embeddingKey: () => env.DATANOTES_EMBEDDING_KEY || keyFromFile(),
     version: VERSION,
     hostName: "service",
@@ -22247,7 +22419,7 @@ Docs: https://datanotes.dev`;
 }
 
 // src/node/cli.ts
-var VERSION2 = true ? "1.2.1" : "dev";
+var VERSION2 = true ? "1.4.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.4.0",
   "description": "The engine of your second brain: Markdown notes as database tables, for you and your agents.",
   "keywords": [
     "markdown",