Remove unused legacy migration path

Author: philcunliffe

src/collector.js

@@ -59,7 +59,6 @@ class Collector {
 
   start() {
     ensureDir(this.outputDir)
-    migrateLegacyServiceFiles(this.outputDir)
 
     const server = createServer(this.handleData.bind(this))
     this.server = server
@@ -161,169 +160,6 @@ function appendLegacyNormalizedLogRow(outputDir, serviceName, row) {
   fs.appendFileSync(filePath, JSON.stringify(row) + '\n')
 }
 
-/**
- * Convert previously written raw service envelope files into normalized rows.
- *
- * Older builds accidentally wrote raw OTLP envelopes to services/<service>/.
- * The services tree is now the normalized browse view, so migrate those files
- * in place and preserve the originals under services-raw/.
- *
- * @param {string} outputDir
- * @returns {void}
- */
-function migrateLegacyServiceFiles(outputDir) {
-  const servicesDir = path.join(outputDir, 'services')
-  if (!fs.existsSync(servicesDir)) return
-  /** @type {{ filePath: string, fileName: string, serviceDirName: string, rawText: string, rows: NormalizedServiceRow[] }[]} */
-  const legacyFiles = []
-
-  for (const serviceDirName of fs.readdirSync(servicesDir)) {
-    const serviceDir = path.join(servicesDir, serviceDirName)
-    if (!safeStat(serviceDir)?.isDirectory()) continue
-
-    for (const fileName of fs.readdirSync(serviceDir)) {
-      const match = fileName.match(/^(logs|traces|metrics)-\d{4}-\d{2}-\d{2}\.jsonl$/)
-      if (!match) continue
-
-      const signal = match[1]
-      const collectionKey = signalCollectionKey(signal)
-      if (!collectionKey) continue
-
-      const filePath = path.join(serviceDir, fileName)
-      if (!fileContainsLegacyRawEnvelope(filePath, collectionKey)) continue
-
-      const rawText = fs.readFileSync(filePath, 'utf8')
-      legacyFiles.push({
-        filePath,
-        fileName,
-        serviceDirName,
-        rawText,
-        rows: flattenSignalText(signal, rawText),
-      })
-    }
-  }
-
-  /** @type {Map<string, NormalizedServiceRow[]>} */
-  const migratedRowsByFilePath = new Map()
-  for (const legacyFile of legacyFiles) {
-    preserveLegacyServiceRawFile(outputDir, legacyFile.serviceDirName, legacyFile.fileName, legacyFile.rawText)
-    groupMigratedRowsByTargetFile(servicesDir, legacyFile.fileName, legacyFile.rows, migratedRowsByFilePath)
-  }
-
-  const legacyFilePaths = new Set(legacyFiles.map((legacyFile) => legacyFile.filePath))
-  for (const legacyFile of legacyFiles) {
-    writeRowsFile(legacyFile.filePath, migratedRowsByFilePath.get(legacyFile.filePath) ?? [])
-  }
-
-  for (const [filePath, rows] of migratedRowsByFilePath) {
-    if (legacyFilePaths.has(filePath)) continue
-    appendRowsFile(filePath, rows)
-  }
-}
-
-/**
- * @param {string} outputDir
- * @param {string} serviceDirName
- * @param {string} fileName
- * @param {string} rawText
- * @returns {void}
- */
-function preserveLegacyServiceRawFile(outputDir, serviceDirName, fileName, rawText) {
-  const rawDir = path.join(outputDir, 'services-raw', serviceDirName)
-  ensureDir(rawDir)
-  const rawPath = path.join(rawDir, fileName)
-  if (fs.existsSync(rawPath)) {
-    fs.appendFileSync(rawPath, rawText)
-    return
-  }
-  fs.writeFileSync(rawPath, rawText)
-}
-
-/**
- * Legacy raw service files can contain rows for multiple actual services, so
- * repartition them by each normalized row's serviceName before rewriting.
- *
- * @param {string} servicesDir
- * @param {string} fileName
- * @param {NormalizedServiceRow[]} rows
- * @param {Map<string, NormalizedServiceRow[]>} rowsByFilePath
- * @returns {void}
- */
-function groupMigratedRowsByTargetFile(servicesDir, fileName, rows, rowsByFilePath) {
-  for (const row of rows) {
-    const serviceName = sanitizePathSegment(row.serviceName || '_unknown')
-    const filePath = path.join(servicesDir, serviceName, fileName)
-    const existingRows = rowsByFilePath.get(filePath)
-    if (existingRows) {
-      existingRows.push(row)
-    } else {
-      rowsByFilePath.set(filePath, [row])
-    }
-  }
-}
-
-/**
- * @param {string} filePath
- * @param {NormalizedServiceRow[]} rows
- * @returns {void}
- */
-function writeRowsFile(filePath, rows) {
-  ensureDir(path.dirname(filePath))
-  const text = rows.map((row) => JSON.stringify(row)).join('\n')
-  fs.writeFileSync(filePath, text ? `${text}\n` : '')
-}
-
-/**
- * @param {string} filePath
- * @param {NormalizedServiceRow[]} rows
- * @returns {void}
- */
-function appendRowsFile(filePath, rows) {
-  if (!rows.length) return
-  ensureDir(path.dirname(filePath))
-  const text = rows.map((row) => JSON.stringify(row)).join('\n')
-  fs.appendFileSync(filePath, `${text}\n`)
-}
-
-/**
- * @param {string} filePath
- * @param {'resourceLogs' | 'resourceSpans' | 'resourceMetrics'} collectionKey
- * @returns {boolean}
- */
-function fileContainsLegacyRawEnvelope(filePath, collectionKey) {
-  const text = fs.readFileSync(filePath, 'utf8')
-  const firstLine = text.split('\n').find(line => line.trim().length > 0)
-  if (!firstLine) return false
-
-  try {
-    const parsed = JSON.parse(firstLine)
-    return Array.isArray(objectRecord(parsed)?.[collectionKey])
-  } catch {
-    return false
-  }
-}
-
-/**
- * @param {string} signal
- * @param {string} text
- * @returns {NormalizedServiceRow[]}
- */
-function flattenSignalText(signal, text) {
-  /** @type {NormalizedServiceRow[]} */
-  const rows = []
-
-  for (const line of text.split('\n')) {
-    if (!line.trim()) continue
-    try {
-      rows.push(...flattenSignalRows(signal, JSON.parse(line)))
-    } catch {
-      // skip malformed lines during migration
-    }
-  }
-
-  return rows
-}
-
 /**
  * @param {string} signal
  * @param {unknown} data
@@ -336,16 +172,6 @@ function flattenSignalRows(signal, data) {
   return []
 }
 
-/**
- * @param {string} signal
- * @returns {'resourceLogs' | 'resourceSpans' | 'resourceMetrics' | undefined}
- */
-function signalCollectionKey(signal) {
-  if (signal === 'logs') return 'resourceLogs'
-  if (signal === 'traces') return 'resourceSpans'
-  if (signal === 'metrics') return 'resourceMetrics'
-}
-
 /**
  * Flatten OTLP log export envelopes into one normalized row per log record.
  *
@@ -922,18 +748,6 @@ function ensureDir(dir) {
   }
 }
 
-/**
- * @param {string} filePath
- * @returns {fs.Stats | undefined}
- */
-function safeStat(filePath) {
-  try {
-    return fs.statSync(filePath)
-  } catch {
-    return undefined
-  }
-}
-
 /**
  * @param {unknown} value
  * @returns {Record<string, unknown> | undefined}

test/server.test.js

@@ -63,19 +63,6 @@ function readServiceLines(serviceName, signal) {
   return text.split('\n').map((line) => JSON.parse(line))
 }
 
-/**
- * @param {string} serviceName
- * @param {string} signal
- * @returns {unknown[]}
- */
-function readPreservedServiceRawLines(serviceName, signal) {
-  const file = path.join(outputDir, 'services-raw', serviceName, `${signal}-${new Date().toISOString().slice(0, 10)}.jsonl`)
-  if (!fs.existsSync(file)) return []
-  const text = fs.readFileSync(file, 'utf8').trim()
-  if (!text) return []
-  return text.split('\n').map((line) => JSON.parse(line))
-}
-
 /**
  * @param {number | bigint} value
  * @returns {Buffer}
@@ -344,123 +331,6 @@ describe('OTLP endpoints', () => {
     expect(readLines('logs')).toEqual([{ n: 1 }, { n: 2 }])
   })
 
-  it('migrates legacy raw service files to normalized rows on startup', async () => {
-    await collector.stop()
-
-    const legacyPayload = {
-      resourceSpans: [
-        {
-          resource: {
-            attributes: [
-              { key: 'service.name', value: { stringValue: 'svc-legacy' } },
-            ],
-          },
-          scopeSpans: [
-            {
-              spans: [
-                { name: 'legacy span' },
-              ],
-            },
-          ],
-        },
-      ],
-    }
-
-    const file = path.join(outputDir, 'services', 'svc-legacy', `traces-${new Date().toISOString().slice(0, 10)}.jsonl`)
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    fs.writeFileSync(file, JSON.stringify(legacyPayload) + '\n')
-
-    collector = new Collector({ port: 0, outputDir })
-    await collector.start()
-
-    expect(readServiceLines('svc-legacy', 'traces')).toEqual([
-      expect.objectContaining({
-        serviceName: 'svc-legacy',
-        name: 'legacy span',
-        resource: { 'service.name': 'svc-legacy' },
-      }),
-    ])
-    expect(readPreservedServiceRawLines('svc-legacy', 'traces')).toEqual([legacyPayload])
-  })
-
-  it('repartitions migrated legacy rows by each row service name', async () => {
-    await collector.stop()
-
-    const legacyPayload = {
-      resourceSpans: [
-        {
-          resource: {
-            attributes: [
-              { key: 'service.name', value: { stringValue: 'svc-a' } },
-            ],
-          },
-          scopeSpans: [
-            {
-              spans: [
-                { name: 'span-a' },
-              ],
-            },
-          ],
-        },
-        {
-          resource: {
-            attributes: [
-              { key: 'service.name', value: { stringValue: 'svc-b' } },
-            ],
-          },
-          scopeSpans: [
-            {
-              spans: [
-                { name: 'span-b' },
-              ],
-            },
-          ],
-        },
-        {
-          resource: { attributes: [] },
-          scopeSpans: [
-            {
-              spans: [
-                { name: 'span-unknown' },
-              ],
-            },
-          ],
-        },
-      ],
-    }
-
-    const file = path.join(outputDir, 'services', 'svc-source', `traces-${new Date().toISOString().slice(0, 10)}.jsonl`)
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    fs.writeFileSync(file, JSON.stringify(legacyPayload) + '\n')
-
-    collector = new Collector({ port: 0, outputDir })
-    await collector.start()
-
-    expect(readServiceLines('svc-a', 'traces')).toEqual([
-      expect.objectContaining({
-        serviceName: 'svc-a',
-        name: 'span-a',
-        resource: { 'service.name': 'svc-a' },
-      }),
-    ])
-    expect(readServiceLines('svc-b', 'traces')).toEqual([
-      expect.objectContaining({
-        serviceName: 'svc-b',
-        name: 'span-b',
-        resource: { 'service.name': 'svc-b' },
-      }),
-    ])
-    expect(readServiceLines('_unknown', 'traces')).toEqual([
-      expect.objectContaining({
-        serviceName: '_unknown',
-        name: 'span-unknown',
-        resource: {},
-      }),
-    ])
-    expect(readServiceLines('svc-source', 'traces')).toEqual([])
-    expect(readPreservedServiceRawLines('svc-source', 'traces')).toEqual([legacyPayload])
-  })
-
   it('writes normalized one-row-per-log-record files partitioned by service.name', async () => {
     const payload = {
       resourceLogs: [