admin/Moltbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: rename to openclaw

Browse Source
This commit is contained in:
Peter Steinberger
2026-01-30 03:15:10 +01:00
parent 4583f88626
commit 9a7160786a
2357 changed files with 16688 additions and 16788 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
extensions/diagnostics-otel/index.ts
View File

@@ -1,5 +1,5 @@
import type { MoltbotPluginApi } from "clawdbot/plugin-sdk";
import { emptyPluginConfigSchema } from "clawdbot/plugin-sdk";
import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
import { createDiagnosticsOtelService } from "./src/service.js";
@@ -8,7 +8,7 @@ const plugin = {
name: "Diagnostics OpenTelemetry",
description: "Export diagnostics events to OpenTelemetry",
configSchema: emptyPluginConfigSchema(),
register(api: MoltbotPluginApi) {
register(api: OpenClawPluginApi) {
api.registerService(createDiagnosticsOtelService());
},
};

0
extensions/diagnostics-otel/clawdbot.plugin.json → extensions/diagnostics-otel/openclaw.plugin.json
View File

8
extensions/diagnostics-otel/package.json
View File

@@ -1,9 +1,9 @@
{
"name": "@moltbot/diagnostics-otel",
"version": "2026.1.29",
"name": "@openclaw/diagnostics-otel",
"version": "2026.1.27-beta.1",
"type": "module",
"description": "Moltbot diagnostics OpenTelemetry exporter",
"moltbot": {
"description": "OpenClaw diagnostics OpenTelemetry exporter",
"openclaw": {
"extensions": [
"./index.ts"
]

30
extensions/diagnostics-otel/src/service.test.ts
View File

@@ -95,8 +95,8 @@ vi.mock("@opentelemetry/semantic-conventions", () => ({
},
}));
vi.mock("clawdbot/plugin-sdk", async () => {
const actual = await vi.importActual<typeof import("clawdbot/plugin-sdk")>("clawdbot/plugin-sdk");
vi.mock("openclaw/plugin-sdk", async () => {
const actual = await vi.importActual<typeof import("openclaw/plugin-sdk")>("openclaw/plugin-sdk");
return {
...actual,
registerLogTransport: registerLogTransportMock,
@@ -104,7 +104,7 @@ vi.mock("clawdbot/plugin-sdk", async () => {
});
import { createDiagnosticsOtelService } from "./service.js";
import { emitDiagnosticEvent } from "clawdbot/plugin-sdk";
import { emitDiagnosticEvent } from "openclaw/plugin-sdk";
describe("diagnostics-otel service", () => {
beforeEach(() => {
@@ -191,20 +191,20 @@ describe("diagnostics-otel service", () => {
attempt: 2,
});
expect(telemetryState.counters.get("moltbot.webhook.received")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("moltbot.webhook.duration_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("moltbot.message.queued")?.add).toHaveBeenCalled();
expect(telemetryState.counters.get("moltbot.message.processed")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("moltbot.message.duration_ms")?.record).toHaveBeenCalled();
expect(telemetryState.histograms.get("moltbot.queue.wait_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("moltbot.session.stuck")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("moltbot.session.stuck_age_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("moltbot.run.attempt")?.add).toHaveBeenCalled();
expect(telemetryState.counters.get("openclaw.webhook.received")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("openclaw.webhook.duration_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("openclaw.message.queued")?.add).toHaveBeenCalled();
expect(telemetryState.counters.get("openclaw.message.processed")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("openclaw.message.duration_ms")?.record).toHaveBeenCalled();
expect(telemetryState.histograms.get("openclaw.queue.wait_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("openclaw.session.stuck")?.add).toHaveBeenCalled();
expect(telemetryState.histograms.get("openclaw.session.stuck_age_ms")?.record).toHaveBeenCalled();
expect(telemetryState.counters.get("openclaw.run.attempt")?.add).toHaveBeenCalled();
const spanNames = telemetryState.tracer.startSpan.mock.calls.map((call) => call[0]);
expect(spanNames).toContain("moltbot.webhook.processed");
expect(spanNames).toContain("moltbot.message.processed");
expect(spanNames).toContain("moltbot.session.stuck");
expect(spanNames).toContain("openclaw.webhook.processed");
expect(spanNames).toContain("openclaw.message.processed");
expect(spanNames).toContain("openclaw.session.stuck");
expect(registerLogTransportMock).toHaveBeenCalledTimes(1);
expect(registeredTransports).toHaveLength(1);

170
extensions/diagnostics-otel/src/service.ts
View File

@@ -10,10 +10,10 @@ import { NodeSDK } from "@opentelemetry/sdk-node";
import { ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
import type { MoltbotPluginService, DiagnosticEventPayload } from "clawdbot/plugin-sdk";
import { onDiagnosticEvent, registerLogTransport } from "clawdbot/plugin-sdk";
import type { DiagnosticEventPayload, OpenClawPluginService } from "openclaw/plugin-sdk";
import { onDiagnosticEvent, registerLogTransport } from "openclaw/plugin-sdk";
const DEFAULT_SERVICE_NAME = "moltbot";
const DEFAULT_SERVICE_NAME = "openclaw";
function normalizeEndpoint(endpoint?: string): string | undefined {
const trimmed = endpoint?.trim();
@@ -32,7 +32,7 @@ function resolveSampleRate(value: number | undefined): number | undefined {
return value;
}
export function createDiagnosticsOtelService(): MoltbotPluginService {
export function createDiagnosticsOtelService(): OpenClawPluginService {
let sdk: NodeSDK | null = null;
let logProvider: LoggerProvider | null = null;
let stopLogTransport: (() => void) | null = null;
@@ -118,78 +118,78 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
FATAL: 21 as SeverityNumber,
};
const meter = metrics.getMeter("moltbot");
const tracer = trace.getTracer("moltbot");
const meter = metrics.getMeter("openclaw");
const tracer = trace.getTracer("openclaw");
const tokensCounter = meter.createCounter("moltbot.tokens", {
const tokensCounter = meter.createCounter("openclaw.tokens", {
unit: "1",
description: "Token usage by type",
});
const costCounter = meter.createCounter("moltbot.cost.usd", {
const costCounter = meter.createCounter("openclaw.cost.usd", {
unit: "1",
description: "Estimated model cost (USD)",
});
const durationHistogram = meter.createHistogram("moltbot.run.duration_ms", {
const durationHistogram = meter.createHistogram("openclaw.run.duration_ms", {
unit: "ms",
description: "Agent run duration",
});
const contextHistogram = meter.createHistogram("moltbot.context.tokens", {
const contextHistogram = meter.createHistogram("openclaw.context.tokens", {
unit: "1",
description: "Context window size and usage",
});
const webhookReceivedCounter = meter.createCounter("moltbot.webhook.received", {
const webhookReceivedCounter = meter.createCounter("openclaw.webhook.received", {
unit: "1",
description: "Webhook requests received",
});
const webhookErrorCounter = meter.createCounter("moltbot.webhook.error", {
const webhookErrorCounter = meter.createCounter("openclaw.webhook.error", {
unit: "1",
description: "Webhook processing errors",
});
const webhookDurationHistogram = meter.createHistogram("moltbot.webhook.duration_ms", {
const webhookDurationHistogram = meter.createHistogram("openclaw.webhook.duration_ms", {
unit: "ms",
description: "Webhook processing duration",
});
const messageQueuedCounter = meter.createCounter("moltbot.message.queued", {
const messageQueuedCounter = meter.createCounter("openclaw.message.queued", {
unit: "1",
description: "Messages queued for processing",
});
const messageProcessedCounter = meter.createCounter("moltbot.message.processed", {
const messageProcessedCounter = meter.createCounter("openclaw.message.processed", {
unit: "1",
description: "Messages processed by outcome",
});
const messageDurationHistogram = meter.createHistogram("moltbot.message.duration_ms", {
const messageDurationHistogram = meter.createHistogram("openclaw.message.duration_ms", {
unit: "ms",
description: "Message processing duration",
});
const queueDepthHistogram = meter.createHistogram("moltbot.queue.depth", {
const queueDepthHistogram = meter.createHistogram("openclaw.queue.depth", {
unit: "1",
description: "Queue depth on enqueue/dequeue",
});
const queueWaitHistogram = meter.createHistogram("moltbot.queue.wait_ms", {
const queueWaitHistogram = meter.createHistogram("openclaw.queue.wait_ms", {
unit: "ms",
description: "Queue wait time before execution",
});
const laneEnqueueCounter = meter.createCounter("moltbot.queue.lane.enqueue", {
const laneEnqueueCounter = meter.createCounter("openclaw.queue.lane.enqueue", {
unit: "1",
description: "Command queue lane enqueue events",
});
const laneDequeueCounter = meter.createCounter("moltbot.queue.lane.dequeue", {
const laneDequeueCounter = meter.createCounter("openclaw.queue.lane.dequeue", {
unit: "1",
description: "Command queue lane dequeue events",
});
const sessionStateCounter = meter.createCounter("moltbot.session.state", {
const sessionStateCounter = meter.createCounter("openclaw.session.state", {
unit: "1",
description: "Session state transitions",
});
const sessionStuckCounter = meter.createCounter("moltbot.session.stuck", {
const sessionStuckCounter = meter.createCounter("openclaw.session.stuck", {
unit: "1",
description: "Sessions stuck in processing",
});
const sessionStuckAgeHistogram = meter.createHistogram("moltbot.session.stuck_age_ms", {
const sessionStuckAgeHistogram = meter.createHistogram("openclaw.session.stuck_age_ms", {
unit: "ms",
description: "Age of stuck sessions",
});
const runAttemptCounter = meter.createCounter("moltbot.run.attempt", {
const runAttemptCounter = meter.createCounter("openclaw.run.attempt", {
unit: "1",
description: "Run attempts",
});
@@ -207,7 +207,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
: {}),
}),
);
const otelLogger = logProvider.getLogger("moltbot");
const otelLogger = logProvider.getLogger("openclaw");
stopLogTransport = registerLogTransport((logObj) => {
const safeStringify = (value: unknown) => {
@@ -265,29 +265,29 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
}
const attributes: Record<string, string | number | boolean> = {
"moltbot.log.level": logLevelName,
"openclaw.log.level": logLevelName,
};
if (meta?.name) attributes["moltbot.logger"] = meta.name;
if (meta?.name) attributes["openclaw.logger"] = meta.name;
if (meta?.parentNames?.length) {
attributes["moltbot.logger.parents"] = meta.parentNames.join(".");
attributes["openclaw.logger.parents"] = meta.parentNames.join(".");
}
if (bindings) {
for (const [key, value] of Object.entries(bindings)) {
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
attributes[`moltbot.${key}`] = value;
attributes[`openclaw.${key}`] = value;
} else if (value != null) {
attributes[`moltbot.${key}`] = safeStringify(value);
attributes[`openclaw.${key}`] = safeStringify(value);
}
}
}
if (numericArgs.length > 0) {
attributes["moltbot.log.args"] = safeStringify(numericArgs);
attributes["openclaw.log.args"] = safeStringify(numericArgs);
}
if (meta?.path?.filePath) attributes["code.filepath"] = meta.path.filePath;
if (meta?.path?.fileLine) attributes["code.lineno"] = Number(meta.path.fileLine);
if (meta?.path?.method) attributes["code.function"] = meta.path.method;
if (meta?.path?.filePathWithLine) {
attributes["moltbot.code.location"] = meta.path.filePathWithLine;
attributes["openclaw.code.location"] = meta.path.filePathWithLine;
}
otelLogger.emit({
@@ -316,48 +316,48 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
const recordModelUsage = (evt: Extract<DiagnosticEventPayload, { type: "model.usage" }>) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.provider": evt.provider ?? "unknown",
"moltbot.model": evt.model ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.provider": evt.provider ?? "unknown",
"openclaw.model": evt.model ?? "unknown",
};
const usage = evt.usage;
if (usage.input) tokensCounter.add(usage.input, { ...attrs, "moltbot.token": "input" });
if (usage.output) tokensCounter.add(usage.output, { ...attrs, "moltbot.token": "output" });
if (usage.input) tokensCounter.add(usage.input, { ...attrs, "openclaw.token": "input" });
if (usage.output) tokensCounter.add(usage.output, { ...attrs, "openclaw.token": "output" });
if (usage.cacheRead)
tokensCounter.add(usage.cacheRead, { ...attrs, "moltbot.token": "cache_read" });
tokensCounter.add(usage.cacheRead, { ...attrs, "openclaw.token": "cache_read" });
if (usage.cacheWrite)
tokensCounter.add(usage.cacheWrite, { ...attrs, "moltbot.token": "cache_write" });
tokensCounter.add(usage.cacheWrite, { ...attrs, "openclaw.token": "cache_write" });
if (usage.promptTokens)
tokensCounter.add(usage.promptTokens, { ...attrs, "moltbot.token": "prompt" });
if (usage.total) tokensCounter.add(usage.total, { ...attrs, "moltbot.token": "total" });
tokensCounter.add(usage.promptTokens, { ...attrs, "openclaw.token": "prompt" });
if (usage.total) tokensCounter.add(usage.total, { ...attrs, "openclaw.token": "total" });
if (evt.costUsd) costCounter.add(evt.costUsd, attrs);
if (evt.durationMs) durationHistogram.record(evt.durationMs, attrs);
if (evt.context?.limit)
contextHistogram.record(evt.context.limit, {
...attrs,
"moltbot.context": "limit",
"openclaw.context": "limit",
});
if (evt.context?.used)
contextHistogram.record(evt.context.used, {
...attrs,
"moltbot.context": "used",
"openclaw.context": "used",
});
if (!tracesEnabled) return;
const spanAttrs: Record<string, string | number> = {
...attrs,
"moltbot.sessionKey": evt.sessionKey ?? "",
"moltbot.sessionId": evt.sessionId ?? "",
"moltbot.tokens.input": usage.input ?? 0,
"moltbot.tokens.output": usage.output ?? 0,
"moltbot.tokens.cache_read": usage.cacheRead ?? 0,
"moltbot.tokens.cache_write": usage.cacheWrite ?? 0,
"moltbot.tokens.total": usage.total ?? 0,
"openclaw.sessionKey": evt.sessionKey ?? "",
"openclaw.sessionId": evt.sessionId ?? "",
"openclaw.tokens.input": usage.input ?? 0,
"openclaw.tokens.output": usage.output ?? 0,
"openclaw.tokens.cache_read": usage.cacheRead ?? 0,
"openclaw.tokens.cache_write": usage.cacheWrite ?? 0,
"openclaw.tokens.total": usage.total ?? 0,
};
const span = spanWithDuration("moltbot.model.usage", spanAttrs, evt.durationMs);
const span = spanWithDuration("openclaw.model.usage", spanAttrs, evt.durationMs);
span.end();
};
@@ -365,8 +365,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
evt: Extract<DiagnosticEventPayload, { type: "webhook.received" }>,
) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.webhook": evt.updateType ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.webhook": evt.updateType ?? "unknown",
};
webhookReceivedCounter.add(1, attrs);
};
@@ -375,16 +375,16 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
evt: Extract<DiagnosticEventPayload, { type: "webhook.processed" }>,
) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.webhook": evt.updateType ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.webhook": evt.updateType ?? "unknown",
};
if (typeof evt.durationMs === "number") {
webhookDurationHistogram.record(evt.durationMs, attrs);
}
if (!tracesEnabled) return;
const spanAttrs: Record<string, string | number> = { ...attrs };
if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
const span = spanWithDuration("moltbot.webhook.processed", spanAttrs, evt.durationMs);
if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
const span = spanWithDuration("openclaw.webhook.processed", spanAttrs, evt.durationMs);
span.end();
};
@@ -392,17 +392,17 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
evt: Extract<DiagnosticEventPayload, { type: "webhook.error" }>,
) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.webhook": evt.updateType ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.webhook": evt.updateType ?? "unknown",
};
webhookErrorCounter.add(1, attrs);
if (!tracesEnabled) return;
const spanAttrs: Record<string, string | number> = {
...attrs,
"moltbot.error": evt.error,
"openclaw.error": evt.error,
};
if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
const span = tracer.startSpan("moltbot.webhook.error", {
if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
const span = tracer.startSpan("openclaw.webhook.error", {
attributes: spanAttrs,
});
span.setStatus({ code: SpanStatusCode.ERROR, message: evt.error });
@@ -413,8 +413,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
evt: Extract<DiagnosticEventPayload, { type: "message.queued" }>,
) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.source": evt.source ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.source": evt.source ?? "unknown",
};
messageQueuedCounter.add(1, attrs);
if (typeof evt.queueDepth === "number") {
@@ -426,8 +426,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
evt: Extract<DiagnosticEventPayload, { type: "message.processed" }>,
) => {
const attrs = {
"moltbot.channel": evt.channel ?? "unknown",
"moltbot.outcome": evt.outcome ?? "unknown",
"openclaw.channel": evt.channel ?? "unknown",
"openclaw.outcome": evt.outcome ?? "unknown",
};
messageProcessedCounter.add(1, attrs);
if (typeof evt.durationMs === "number") {
@@ -435,12 +435,12 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
}
if (!tracesEnabled) return;
const spanAttrs: Record<string, string | number> = { ...attrs };
if (evt.sessionKey) spanAttrs["moltbot.sessionKey"] = evt.sessionKey;
if (evt.sessionId) spanAttrs["moltbot.sessionId"] = evt.sessionId;
if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
if (evt.messageId !== undefined) spanAttrs["moltbot.messageId"] = String(evt.messageId);
if (evt.reason) spanAttrs["moltbot.reason"] = evt.reason;
const span = spanWithDuration("moltbot.message.processed", spanAttrs, evt.durationMs);
if (evt.sessionKey) spanAttrs["openclaw.sessionKey"] = evt.sessionKey;
if (evt.sessionId) spanAttrs["openclaw.sessionId"] = evt.sessionId;
if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
if (evt.messageId !== undefined) spanAttrs["openclaw.messageId"] = String(evt.messageId);
if (evt.reason) spanAttrs["openclaw.reason"] = evt.reason;
const span = spanWithDuration("openclaw.message.processed", spanAttrs, evt.durationMs);
if (evt.outcome === "error") {
span.setStatus({ code: SpanStatusCode.ERROR, message: evt.error });
}
@@ -450,7 +450,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
const recordLaneEnqueue = (
evt: Extract<DiagnosticEventPayload, { type: "queue.lane.enqueue" }>,
) => {
const attrs = { "moltbot.lane": evt.lane };
const attrs = { "openclaw.lane": evt.lane };
laneEnqueueCounter.add(1, attrs);
queueDepthHistogram.record(evt.queueSize, attrs);
};
@@ -458,7 +458,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
const recordLaneDequeue = (
evt: Extract<DiagnosticEventPayload, { type: "queue.lane.dequeue" }>,
) => {
const attrs = { "moltbot.lane": evt.lane };
const attrs = { "openclaw.lane": evt.lane };
laneDequeueCounter.add(1, attrs);
queueDepthHistogram.record(evt.queueSize, attrs);
if (typeof evt.waitMs === "number") {
@@ -469,38 +469,38 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
const recordSessionState = (
evt: Extract<DiagnosticEventPayload, { type: "session.state" }>,
) => {
const attrs: Record<string, string> = { "moltbot.state": evt.state };
if (evt.reason) attrs["moltbot.reason"] = evt.reason;
const attrs: Record<string, string> = { "openclaw.state": evt.state };
if (evt.reason) attrs["openclaw.reason"] = evt.reason;
sessionStateCounter.add(1, attrs);
};
const recordSessionStuck = (
evt: Extract<DiagnosticEventPayload, { type: "session.stuck" }>,
) => {
const attrs: Record<string, string> = { "moltbot.state": evt.state };
const attrs: Record<string, string> = { "openclaw.state": evt.state };
sessionStuckCounter.add(1, attrs);
if (typeof evt.ageMs === "number") {
sessionStuckAgeHistogram.record(evt.ageMs, attrs);
}
if (!tracesEnabled) return;
const spanAttrs: Record<string, string | number> = { ...attrs };
if (evt.sessionKey) spanAttrs["moltbot.sessionKey"] = evt.sessionKey;
if (evt.sessionId) spanAttrs["moltbot.sessionId"] = evt.sessionId;
spanAttrs["moltbot.queueDepth"] = evt.queueDepth ?? 0;
spanAttrs["moltbot.ageMs"] = evt.ageMs;
const span = tracer.startSpan("moltbot.session.stuck", { attributes: spanAttrs });
if (evt.sessionKey) spanAttrs["openclaw.sessionKey"] = evt.sessionKey;
if (evt.sessionId) spanAttrs["openclaw.sessionId"] = evt.sessionId;
spanAttrs["openclaw.queueDepth"] = evt.queueDepth ?? 0;
spanAttrs["openclaw.ageMs"] = evt.ageMs;
const span = tracer.startSpan("openclaw.session.stuck", { attributes: spanAttrs });
span.setStatus({ code: SpanStatusCode.ERROR, message: "session stuck" });
span.end();
};
const recordRunAttempt = (evt: Extract<DiagnosticEventPayload, { type: "run.attempt" }>) => {
runAttemptCounter.add(1, { "moltbot.attempt": evt.attempt });
runAttemptCounter.add(1, { "openclaw.attempt": evt.attempt });
};
const recordHeartbeat = (
evt: Extract<DiagnosticEventPayload, { type: "diagnostic.heartbeat" }>,
) => {
queueDepthHistogram.record(evt.queued, { "moltbot.channel": "heartbeat" });
queueDepthHistogram.record(evt.queued, { "openclaw.channel": "heartbeat" });
};
unsubscribe = onDiagnosticEvent((evt: DiagnosticEventPayload) => {
@@ -562,5 +562,5 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
sdk = null;
}
},
} satisfies MoltbotPluginService;
} satisfies OpenClawPluginService;
}