@ciphyrshq/sdk 3.0.0 → 3.0.1

package/src/tracer.test.js

@@ -1,194 +0,0 @@
-/**
- * CiphyrsTracer — buffered span and metric ingestion.
- * Run with: npm test
- *
- * This is the only route spans, traces and metrics take to the platform, and
- * its failure mode is silence: when ingestion breaks nothing errors, data just
- * never arrives, and an empty dashboard is indistinguishable from a quiet day.
- *
- * The buffers are spliced empty BEFORE the send, so a `.catch` that only
- * logged meant any failure the client's retries could not absorb destroyed
- * that batch permanently. sdk-node's client.js already re-queued; this package
- * did not, so the same customer got different durability from two Ciphyrs
- * SDKs doing the same job.
- */
-
-// No test in this package may open a socket — see no-network.test-helper.js.
-// Imported per file because node --test runs each file in its own process.
-import './no-network.test-helper.js'
-import { describe, it, beforeEach, afterEach } from 'node:test'
-import assert from 'node:assert/strict'
-import { CiphyrsTracer } from './tracer.js'
-
-// console.error is the delivery mechanism for "your telemetry is not arriving",
-// so it is asserted on rather than silenced.
-let logged
-let realError
-beforeEach(() => { logged = []; realError = console.error; console.error = (m) => logged.push(String(m)) })
-afterEach(() => { console.error = realError })
-
-function fakeClient({ failIngest = false, failMetrics = false } = {}) {
-  const calls = { ingest: [], metrics: [] }
-  return {
-    calls,
-    _baseUrl: 'https://api',
-    trace: {
-      ingest: async (project, trace, spans) => {
-        calls.ingest.push({ trace, spans })
-        if (failIngest) throw new Error('collector unreachable')
-        return { ok: true }
-      },
-    },
-    _request: async (url, opts) => {
-      calls.metrics.push(opts.body)
-      if (failMetrics) throw new Error('collector unreachable')
-      return { ok: true }
-    },
-  }
-}
-
-const tracerFor = (client, opts = {}) =>
-  // flushIntervalMs is large so the timer never races an assertion; every
-  // flush below is explicit.
-  new CiphyrsTracer(client, { projectName: 'billing', flushIntervalMs: 3_600_000, ...opts })
-
-// Reaches the private #spanBuffer the only way a test legitimately can:
-// enqueue, flush, and observe what a subsequent flush still tries to send.
-const pendingSpanCount = async (tracer, client) => {
-  const before = client.calls.ingest.length
-  await tracer.flush()
-  return client.calls.ingest.slice(before).reduce((n, c) => n + c.spans.length, 0)
-}
-
-describe('CiphyrsTracer — a successful flush', () => {
-  it('sends buffered spans grouped into one call per trace', async () => {
-    const client = fakeClient()
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    t._enqueueSpan({ trace_id: 'A', name: 'a2' })
-    t._enqueueSpan({ trace_id: 'B', name: 'b1' })
-    await t.flush()
-    assert.equal(client.calls.ingest.length, 2, 'traces must not be merged')
-    assert.deepEqual(client.calls.ingest.map(c => c.spans.length), [2, 1])
-  })
-
-  it('sends buffered metrics', async () => {
-    const client = fakeClient()
-    const t = tracerFor(client)
-    t.emitMetric('token_cost', 0.42, { unit: 'usd' })
-    await t.flush()
-    assert.equal(client.calls.metrics[0].metrics[0].name, 'token_cost')
-  })
-
-  it('empties the buffers, so nothing is sent twice', async () => {
-    const client = fakeClient()
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    t.emitMetric('m', 1)
-    await t.flush()
-    await t.flush()
-    assert.equal(client.calls.ingest.length, 1)
-    assert.equal(client.calls.metrics.length, 1)
-  })
-
-  it('does nothing when there is nothing buffered', async () => {
-    const client = fakeClient()
-    await tracerFor(client).flush()
-    assert.equal(client.calls.ingest.length + client.calls.metrics.length, 0)
-  })
-})
-
-describe('CiphyrsTracer — a failed flush must not destroy the batch', () => {
-  it('re-queues spans and says so', async () => {
-    const client = fakeClient({ failIngest: true })
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    await t.flush()
-    assert.match(logged.join('\n'), /re-queued/)
-    assert.equal(await pendingSpanCount(t, client), 1, 'the span was destroyed')
-  })
-
-  it('re-queues metrics and says so', async () => {
-    const client = fakeClient({ failMetrics: true })
-    const t = tracerFor(client)
-    t.emitMetric('token_cost', 0.42)
-    await t.flush()
-    const before = client.calls.metrics.length
-    await t.flush()
-    assert.ok(client.calls.metrics.length > before, 'the metric was destroyed')
-    assert.equal(client.calls.metrics.at(-1).metrics[0].name, 'token_cost')
-  })
-
-  it('delivers the batch once the collector comes back', async () => {
-    // Re-queueing is only worth anything if a later attempt picks it up.
-    const client = fakeClient({ failIngest: true })
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    await t.flush()
-    client.trace.ingest = async (p, trace, spans) => {
-      client.calls.ingest.push({ trace, spans }); return { ok: true }
-    }
-    await t.flush()
-    assert.equal(client.calls.ingest.at(-1).spans[0].name, 'a1')
-    // ...and is then gone, not resent forever.
-    const n = client.calls.ingest.length
-    await t.flush()
-    assert.equal(client.calls.ingest.length, n)
-  })
-
-  it('keeps two failed traces in the order they were produced', async () => {
-    // Spans post one trace at a time, so the second failure lands on top of
-    // the first — the one case where re-queueing at the front would silently
-    // reverse the timeline.
-    const client = fakeClient({ failIngest: true })
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    t._enqueueSpan({ trace_id: 'B', name: 'b1' })
-    await t.flush()
-    const before = client.calls.ingest.length
-    await t.flush()
-    const names = client.calls.ingest.slice(before).flatMap(c => c.spans.map(s => s.name))
-    assert.deepEqual(names, ['a1', 'b1'])
-  })
-
-  it('bounds the re-queue so an outage cannot exhaust memory', async () => {
-    // A tracing SDK that OOMs the process it observes is worse than one that
-    // drops telemetry — but it has to say what it dropped.
-    const client = fakeClient({ failIngest: true })
-    const t = tracerFor(client, { batchSize: 5 })   // cap = max(5*20, 1000) = 1000
-    for (let i = 0; i < 1200; i++) t._enqueueSpan({ trace_id: 'A', name: `s${i}` })
-    await t.flush()
-    assert.match(logged.join('\n'), /dropped \d+ oldest/)
-    assert.ok(await pendingSpanCount(t, client) <= 1000)
-  })
-
-  it('drops the oldest, keeping the most recent spans', async () => {
-    const client = fakeClient({ failIngest: true })
-    const t = tracerFor(client, { batchSize: 5 })
-    for (let i = 0; i < 1200; i++) t._enqueueSpan({ trace_id: 'A', name: `s${i}` })
-    await t.flush()
-    const before = client.calls.ingest.length
-    await t.flush()
-    const names = client.calls.ingest.slice(before).flatMap(c => c.spans.map(s => s.name))
-    assert.equal(names.at(-1), 's1199', 'threw away the newest instead of the oldest')
-    assert.ok(!names.includes('s0'))
-  })
-
-  it('a metrics failure does not take the spans down with it', async () => {
-    const client = fakeClient({ failMetrics: true })
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    t.emitMetric('m', 1)
-    await t.flush()
-    assert.equal(client.calls.ingest.length, 1, 'spans were sent')
-    assert.equal(await pendingSpanCount(t, client), 0, 'spans were needlessly re-queued')
-  })
-
-  it('never rejects — observability must not crash the observed process', async () => {
-    const client = fakeClient({ failIngest: true, failMetrics: true })
-    const t = tracerFor(client)
-    t._enqueueSpan({ trace_id: 'A', name: 'a1' })
-    t.emitMetric('m', 1)
-    await t.flush()   // must resolve
-  })
-})