Merge pull request #44 from Jeevan1351/fix-lines-of-code-net-count

Author: dialupdisaster

README.md

@@ -31,7 +31,8 @@ An [opencode](https://opencode.ai) plugin that exports telemetry via OpenTelemet
 | `opencode.session.count` | Counter | Incremented on each `session.created` event |
 | `opencode.token.usage` | Counter | Per token type: `input`, `output`, `reasoning`, `cacheRead`, `cacheCreation` |
 | `opencode.cost.usage` | Counter | USD cost per completed assistant message |
-| `opencode.lines_of_code.count` | Counter | Lines added/removed per `session.diff` event |
+| `opencode.lines_of_code.count` | Counter | **Gross positive churn, not a net total.** Emits the positive delta of `additions`/`deletions` since the previous `session.diff` for the same session; negative deltas (when opencode's cumulative `additions` or `deletions` shrinks vs. the last event) are dropped. Summing the counter therefore reports gross lines added/removed across forward transitions — it does *not* reconcile back to the session's current state after any revert (full or partial). Intra-message rewrites that opencode collapses in its per-message cumulative are not visible here at all. Use `opencode.lines_of_code.total` for the authoritative live cumulative. |
+| `opencode.lines_of_code.total` | Gauge | **Authoritative live cumulative lines added/removed for the session.** Refreshed on every `session.diff` with opencode's current cumulative value. Drops back to `0` if opencode reports a revert to baseline, and tracks partial reverts faithfully. Query this (not the counter) to answer "what does this session currently amount to". |
 | `opencode.commit.count` | Counter | Git commits detected via bash tool |
 | `opencode.tool.duration` | Histogram | Tool execution time in milliseconds |
 | `opencode.cache.count` | Counter | Cache activity per message: `type=cacheRead` or `type=cacheCreation` |
@@ -154,6 +155,9 @@ export OPENCODE_DISABLE_METRICS="retry.count"
 
 # Disable multiple metrics
 export OPENCODE_DISABLE_METRICS="cache.count,session.duration,session.token.total,session.cost.total,model.usage,retry.count,message.count"
+
+# Disable the new per-session cumulative gauge while keeping the delta counter
+export OPENCODE_DISABLE_METRICS="lines_of_code.total"
 ```
 
 #### opencode-only metrics

src/handlers/activity.ts

@@ -1,41 +1,64 @@
 import { SeverityNumber } from "@opentelemetry/api-logs"
 import type { EventSessionDiff, EventCommandExecuted } from "@opencode-ai/sdk"
-import { isMetricEnabled } from "../util.ts"
+import { isMetricEnabled, setBoundedMap } from "../util.ts"
 import type { HandlerContext } from "../types.ts"
 
-/** Records lines-added and lines-removed metrics for each file in the diff. */
+/**
+ * Records lines-added/removed for a `session.diff` event. opencode publishes each event
+ * with the cumulative session diff (first snapshot → latest), so we emit two instruments:
+ * `opencode.lines_of_code.count` (Counter) receives only the *positive* per-event delta
+ * for each dimension (additions, deletions). Negative deltas — opencode reporting a smaller
+ * cumulative for a dimension than the previous event — are dropped, so the counter reports
+ * gross positive churn and does not reconcile to net after any revert (full or partial).
+ * `opencode.lines_of_code.total` (Gauge) mirrors opencode's current cumulative value on
+ * every event and is the authoritative live view.
+ */
 export function handleSessionDiff(e: EventSessionDiff, ctx: HandlerContext) {
   const sessionID = e.properties.sessionID
   const linesEnabled = isMetricEnabled("lines_of_code.count", ctx)
+  const totalEnabled = isMetricEnabled("lines_of_code.total", ctx)
   let totalAdded = 0
   let totalRemoved = 0
   for (const fileDiff of e.properties.diff) {
-    if (fileDiff.additions > 0) {
-      if (linesEnabled) {
-        ctx.instruments.linesCounter.add(fileDiff.additions, {
-          ...ctx.commonAttrs,
-          "session.id": sessionID,
-          type: "added",
-        })
-      }
-      totalAdded += fileDiff.additions
+    totalAdded += fileDiff.additions
+    totalRemoved += fileDiff.deletions
+  }
+
+  const prev = ctx.sessionDiffTotals.get(sessionID) ?? { additions: 0, deletions: 0 }
+  const deltaAdded = totalAdded - prev.additions
+  const deltaRemoved = totalRemoved - prev.deletions
+  const nextTotals = { additions: totalAdded, deletions: totalRemoved }
+  if (ctx.sessionDiffTotals.has(sessionID)) {
+    // Existing session: update in place. Calling setBoundedMap on a full map would
+    // evict an unrelated session here, and that session's next session.diff would
+    // be treated as first-seen — reintroducing the cumulative double-count bug.
+    ctx.sessionDiffTotals.set(sessionID, nextTotals)
+  } else {
+    setBoundedMap(ctx.sessionDiffTotals, sessionID, nextTotals)
+  }
+
+  const baseAttrs = { ...ctx.commonAttrs, "session.id": sessionID }
+
+  if (linesEnabled) {
+    if (deltaAdded > 0) {
+      ctx.instruments.linesCounter.add(deltaAdded, { ...baseAttrs, type: "added" })
     }
-    if (fileDiff.deletions > 0) {
-      if (linesEnabled) {
-        ctx.instruments.linesCounter.add(fileDiff.deletions, {
-          ...ctx.commonAttrs,
-          "session.id": sessionID,
-          type: "removed",
-        })
-      }
-      totalRemoved += fileDiff.deletions
+    if (deltaRemoved > 0) {
+      ctx.instruments.linesCounter.add(deltaRemoved, { ...baseAttrs, type: "removed" })
     }
   }
-  ctx.log("debug", "otel: lines_of_code counter incremented", {
+  if (totalEnabled) {
+    ctx.instruments.linesTotalGauge.record(totalAdded, { ...baseAttrs, type: "added" })
+    ctx.instruments.linesTotalGauge.record(totalRemoved, { ...baseAttrs, type: "removed" })
+  }
+
+  ctx.log("debug", "otel: lines_of_code metrics updated", {
     sessionID,
     files: e.properties.diff.length,
-    added: totalAdded,
-    removed: totalRemoved,
+    deltaAdded,
+    deltaRemoved,
+    totalAdded,
+    totalRemoved,
   })
 }
 

src/handlers/session.ts

@@ -85,6 +85,7 @@ export function handleSessionIdle(e: EventSessionIdle, ctx: HandlerContext) {
   const sessionID = e.properties.sessionID
   const totals = ctx.sessionTotals.get(sessionID)
   ctx.sessionTotals.delete(sessionID)
+  ctx.sessionDiffTotals.delete(sessionID)
   sweepSession(sessionID, ctx)
 
   const attrs = { ...ctx.commonAttrs, "session.id": sessionID }
@@ -144,13 +145,16 @@ export function handleSessionError(e: EventSessionError, ctx: HandlerContext) {
   const rawID = e.properties.sessionID
   const sessionID = rawID ?? "unknown"
   const error = errorSummary(e.properties.error)
-  if (rawID) ctx.sessionTotals.delete(rawID)
+  const totals = rawID ? ctx.sessionTotals.get(rawID) : undefined
+  if (rawID) {
+    ctx.sessionTotals.delete(rawID)
+    ctx.sessionDiffTotals.delete(rawID)
+  }
   sweepSession(sessionID, ctx)
 
   if (rawID) {
     const sessionSpan = ctx.sessionSpans.get(rawID)
     if (sessionSpan) {
-      const totals = ctx.sessionTotals.get(rawID)
       if (totals) sessionSpan.setAttribute(AGENT_NAME, totals.agent)
       sessionSpan.setStatus({ code: SpanStatusCode.ERROR, message: error })
       sessionSpan.setAttribute("error", error)

src/index.ts

@@ -90,6 +90,7 @@ export const OtelPlugin: Plugin = async ({ project, client, directory, worktree
   const pendingToolSpans = new Map()
   const pendingPermissions = new Map()
   const sessionTotals = new Map()
+  const sessionDiffTotals = new Map()
   const sessionSpans = new Map()
   const messageSpans = new Map()
   const sessionInputs = new Map()
@@ -113,6 +114,7 @@ export const OtelPlugin: Plugin = async ({ project, client, directory, worktree
     pendingToolSpans,
     pendingPermissions,
     sessionTotals,
+    sessionDiffTotals,
     disabledMetrics,
     disabledTraces,
     tracer,

src/otel.ts

@@ -154,7 +154,11 @@ export function createInstruments(prefix: string): Instruments {
     }),
     linesCounter: meter.createCounter(`${prefix}lines_of_code.count`, {
       unit: "{line}",
-      description: "Count of lines of code added or removed",
+      description: "Gross positive churn of lines added/removed across a session. Emits the positive delta vs. the previous session.diff; negative deltas (cumulative shrinkage) are dropped, so sums do not reconcile to net after any revert. Use lines_of_code.total for the authoritative live cumulative.",
+    }),
+    linesTotalGauge: meter.createGauge(`${prefix}lines_of_code.total`, {
+      unit: "{line}",
+      description: "Authoritative live cumulative lines added/removed for the current session. Mirrors opencode's session.diff cumulative value on every event; tracks partial and full reverts faithfully.",
     }),
     commitCounter: meter.createCounter(`${prefix}commit.count`, {
       unit: "{commit}",

src/types.ts

@@ -1,4 +1,4 @@
-import type { Counter, Histogram, Span, Tracer } from "@opentelemetry/api"
+import type { Counter, Gauge, Histogram, Span, Tracer } from "@opentelemetry/api"
 import type { Logger as OtelLogger } from "@opentelemetry/api-logs"
 
 /** Numeric priority map for log levels; higher value = higher severity. */
@@ -41,6 +41,7 @@ export type Instruments = {
   tokenCounter: Counter
   costCounter: Counter
   linesCounter: Counter
+  linesTotalGauge: Gauge
   commitCounter: Counter
   toolDurationHistogram: Histogram
   cacheCounter: Counter
@@ -71,6 +72,7 @@ export type HandlerContext = {
   pendingToolSpans: Map<string, PendingToolSpan>
   pendingPermissions: Map<string, PendingPermission>
   sessionTotals: Map<string, SessionTotals>
+  sessionDiffTotals: Map<string, { additions: number; deletions: number }>
   disabledMetrics: Set<string>
   disabledTraces: Set<string>
   tracer: Tracer

tests/handlers/activity.test.ts

@@ -69,6 +69,69 @@ describe("handleSessionDiff", () => {
     handleSessionDiff(makeSessionDiff("ses_1", [{ file: "foo.ts", additions: 0, deletions: 0 }]), ctx)
     expect(counters.lines.calls).toHaveLength(0)
   })
+
+  test("linesCounter emits only positive deltas across multiple events", () => {
+    const { ctx, counters } = makeCtx()
+    // opencode publishes session.diff with the CUMULATIVE session total every event.
+    // Cumulative sequence: 4, 9, 9, 11.  Expected deltas: 4, 5, 0 (skipped), 2.
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 4, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 9, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 9, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 11, deletions: 0 }]), ctx)
+    const added = counters.lines.calls.filter((c) => c.attrs["type"] === "added").map((c) => c.value)
+    expect(added).toEqual([4, 5, 2])
+    expect(added.reduce((a, b) => a + b, 0)).toBe(11) // net, not 4+9+9+11=33
+  })
+
+  test("linesCounter skips negative deltas (revert-to-baseline)", () => {
+    const { ctx, counters } = makeCtx()
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 5, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 0, deletions: 0 }]), ctx)
+    const added = counters.lines.calls.filter((c) => c.attrs["type"] === "added").map((c) => c.value)
+    expect(added).toEqual([5])
+  })
+
+  test("linesCounter is gross-only across a partial revert (additions shrink, deletions grow)", () => {
+    // Cumulative goes {additions:10, deletions:0} -> {additions:5, deletions:5}.
+    // Delta is {added:-5, removed:+5}. Negative added is skipped; positive removed
+    // is emitted. Counter ends at added=10, removed=5 while the authoritative live
+    // cumulative is added=5, removed=5 — the counter is GROSS, not net. Live
+    // cumulative state is surfaced via linesTotalGauge (see next test).
+    const { ctx, counters, gauges } = makeCtx()
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 10, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 5, deletions: 5 }]), ctx)
+
+    const added = counters.lines.calls.filter((c) => c.attrs["type"] === "added").map((c) => c.value)
+    const removed = counters.lines.calls.filter((c) => c.attrs["type"] === "removed").map((c) => c.value)
+    expect(added).toEqual([10])
+    expect(removed).toEqual([5])
+
+    const gaugeAdded = gauges.linesTotal.calls.filter((c) => c.attrs["type"] === "added").map((c) => c.value)
+    const gaugeRemoved = gauges.linesTotal.calls.filter((c) => c.attrs["type"] === "removed").map((c) => c.value)
+    expect(gaugeAdded).toEqual([10, 5])
+    expect(gaugeRemoved).toEqual([0, 5])
+  })
+
+  test("linesTotalGauge records cumulative totals, including zero after revert", () => {
+    const { ctx, gauges } = makeCtx()
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 5, deletions: 2 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 0, deletions: 0 }]), ctx)
+    const added = gauges.linesTotal.calls.filter((c) => c.attrs["type"] === "added").map((c) => c.value)
+    const removed = gauges.linesTotal.calls.filter((c) => c.attrs["type"] === "removed").map((c) => c.value)
+    expect(added).toEqual([5, 0])
+    expect(removed).toEqual([2, 0])
+  })
+
+  test("tracks deltas independently per session", () => {
+    const { ctx, counters } = makeCtx()
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 3, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_2", [{ file: "b.ts", additions: 7, deletions: 0 }]), ctx)
+    handleSessionDiff(makeSessionDiff("ses_1", [{ file: "a.ts", additions: 5, deletions: 0 }]), ctx)
+    const ses1 = counters.lines.calls.filter((c) => c.attrs["session.id"] === "ses_1").map((c) => c.value)
+    const ses2 = counters.lines.calls.filter((c) => c.attrs["session.id"] === "ses_2").map((c) => c.value)
+    expect(ses1).toEqual([3, 2])
+    expect(ses2).toEqual([7])
+  })
 })
 
 describe("handleCommandExecuted", () => {

tests/helpers.ts

@@ -1,6 +1,6 @@
 import type { HandlerContext, Instruments } from "../src/types.ts"
 import type { Logger as OtelLogger, LogRecord } from "@opentelemetry/api-logs"
-import type { Counter, Histogram, Span, SpanOptions, Tracer, Context, SpanContext, SpanStatus, Attributes } from "@opentelemetry/api"
+import type { Counter, Gauge, Histogram, Span, SpanOptions, Tracer, Context, SpanContext, SpanStatus, Attributes } from "@opentelemetry/api"
 import { SpanStatusCode, trace } from "@opentelemetry/api"
 
 export type SpyCounter = {
@@ -13,6 +13,11 @@ export type SpyHistogram = {
   record(value: number, attrs?: Record<string, unknown>): void
 }
 
+export type SpyGauge = {
+  calls: Array<{ value: number; attrs: Record<string, unknown> }>
+  record(value: number, attrs?: Record<string, unknown>): void
+}
+
 export type SpyLogger = {
   records: LogRecord[]
   emit(record: LogRecord): void
@@ -57,6 +62,11 @@ function makeHistogram(): SpyHistogram {
   return spy
 }
 
+function makeGauge(): SpyGauge {
+  const spy: SpyGauge = { calls: [], record(v, a = {}) { spy.calls.push({ value: v, attrs: a }) } }
+  return spy
+}
+
 function makeLogger(): SpyLogger {
   const spy: SpyLogger = { records: [], emit(r) { spy.records.push(r) } }
   return spy
@@ -131,6 +141,7 @@ export type MockContext = {
   gauges: {
     sessionToken: SpyHistogram
     sessionCost: SpyHistogram
+    linesTotal: SpyGauge
   }
   logger: SpyLogger
   pluginLog: SpyPluginLog
@@ -152,6 +163,7 @@ export function makeCtx(projectID = "proj_test", disabledMetrics: string[] = [],
   const sessionDurationHistogram = makeHistogram()
   const sessionTokenGauge = makeHistogram()
   const sessionCostGauge = makeHistogram()
+  const linesTotalGauge = makeGauge()
   const logger = makeLogger()
   const pluginLog = makePluginLog()
   const tracer = makeTracer()
@@ -161,6 +173,7 @@ export function makeCtx(projectID = "proj_test", disabledMetrics: string[] = [],
     tokenCounter: token as unknown as Counter,
     costCounter: cost as unknown as Counter,
     linesCounter: lines as unknown as Counter,
+    linesTotalGauge: linesTotalGauge as unknown as Gauge,
     commitCounter: commit as unknown as Counter,
     toolDurationHistogram: toolHistogram as unknown as Histogram,
     cacheCounter: cache as unknown as Counter,
@@ -181,6 +194,7 @@ export function makeCtx(projectID = "proj_test", disabledMetrics: string[] = [],
     pendingToolSpans: new Map(),
     pendingPermissions: new Map(),
     sessionTotals: new Map(),
+    sessionDiffTotals: new Map(),
     disabledMetrics: new Set(disabledMetrics),
     disabledTraces: new Set(disabledTraces),
     tracer: tracer as unknown as Tracer,
@@ -195,7 +209,7 @@ export function makeCtx(projectID = "proj_test", disabledMetrics: string[] = [],
     ctx,
     counters: { session, token, cost, lines, commit, cache, message, modelUsage, retry, subtask },
     histograms: { tool: toolHistogram, sessionDuration: sessionDurationHistogram },
-    gauges: { sessionToken: sessionTokenGauge, sessionCost: sessionCostGauge },
+    gauges: { sessionToken: sessionTokenGauge, sessionCost: sessionCostGauge, linesTotal: linesTotalGauge },
     logger,
     pluginLog,
     tracer,