logs.spec.js

'use strict'

const assert = require('assert')
const os = require('os')
const http = require('http')

const { describe, it, beforeEach, afterEach } = require('mocha')
const sinon = require('sinon')
const proxyquire = require('proxyquire')
const { logs } = require('@opentelemetry/api-logs')
const { trace, context } = require('@opentelemetry/api')
const { timeInputToHrTime } = require('../../../../vendor/dist/@opentelemetry/core')

require('../setup/core')
const { protoLogsService } = require('../../src/opentelemetry/otlp/protobuf_loader').getProtobufTypes()
const { getConfigFresh } = require('../helpers/config')
const { assertObjectContains } = require('../../../../integration-tests/helpers')

/**
 * @param {object} type protobufjs Type instance for the OTLP service message
 * @param {object} message Decoded protobufjs Message
 * @param {Buffer} originalPayload Raw wire bytes captured from the exporter
 */
function assertWireRoundTrip (type, message, originalPayload) {
  assert(Buffer.isBuffer(originalPayload) && originalPayload.length > 0)
  const reEncoded = Buffer.from(type.encode(message).finish())
  const projectOptions = { longs: String, bytes: String, enums: String }
  assert.deepStrictEqual(
    type.toObject(type.decode(reEncoded), projectOptions),
    type.toObject(message, projectOptions),
  )
}

describe('OpenTelemetry Logs', () => {
  let originalEnv

  function setupLogs (enabled = true, maxExportBatchSize = '1') {
    process.env.DD_LOGS_OTEL_ENABLED = enabled ? 'true' : 'false'
    process.env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE = maxExportBatchSize // Force immediate export

    logs.disable()
    const config = getConfigFresh()
    if (config.DD_LOGS_OTEL_ENABLED) {
      const { initializeOpenTelemetryLogs } =
        proxyquire.noPreserveCache()('../../src/opentelemetry/logs', {})
      initializeOpenTelemetryLogs(config)
    }
    return { config, logs, loggerProvider: logs.getLoggerProvider() }
  }

  // Full tracer.init() path. Needed for tests that assert on runtime pieces only populated by the
  // full pipeline (e.g. the `_dd.rc.client_id` resource attribute added by remote config).
  function setupLogsFull (maxExportBatchSize = '1') {
    process.env.DD_LOGS_OTEL_ENABLED = 'true'
    process.env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE = maxExportBatchSize

    const proxy = proxyquire.noPreserveCache()('../../src/proxy', {
      './config': getConfigFresh,
    })
    const TracerProxy = proxyquire.noPreserveCache()('../../src', {
      './proxy': proxy,
    })
    const tracer = proxyquire.noPreserveCache()('../../', {
      './src': TracerProxy,
    })
    tracer._initialized = false
    tracer.init()
    return { tracer, logs, loggerProvider: logs.getLoggerProvider() }
  }

  function mockOtlpExport (validator, protocol = 'protobuf') {
    let capturedPayload, capturedHeaders
    let validatorCalled = false

    sinon.stub(http, 'request').callsFake((options, onResponse) => {
      // Only intercept OTLP logs requests
      if (options.path && options.path.includes('/v1/logs')) {
        capturedHeaders = options.headers
        const mockReq = {
          write: (data) => { capturedPayload = data },
          end: () => {
            let decoded
            if (protocol === 'json') {
              decoded = JSON.parse(capturedPayload.toString())
            } else {
              const message = protoLogsService.decode(capturedPayload)
              assertWireRoundTrip(protoLogsService, message, capturedPayload)
              decoded = message
            }
            validator(decoded, capturedHeaders)
            validatorCalled = true
          },
          on: () => {},
          once: () => {},
          setTimeout: () => {},
        }
        onResponse({ statusCode: 200, on: () => {}, once: () => {}, setTimeout: () => {} })
        return mockReq
      }

      // For other requests (remote config, etc), return a basic mock
      const mockReq = {
        write: () => {},
        end: () => {},
        on: () => {},
        once: () => {},
        setTimeout: () => {},
      }
      onResponse({ statusCode: 200, on: () => {}, once: () => {}, setTimeout: () => {} })
      return mockReq
    })

    // Return function to check if validator was called
    return () => {
      if (!validatorCalled) {
        throw new Error('OTLP export validator was never called - batch may not have flushed')
      }
    }
  }

  function mockLogWarn () {
    const log = require('../../src/log')
    const originalWarn = log.warn
    let warningMessage = ''
    log.warn = (msg) => { warningMessage = msg }
    return { restore: () => { log.warn = originalWarn }, getMessage: () => warningMessage }
  }

  beforeEach(() => {
    originalEnv = { ...process.env }
  })

  afterEach(() => {
    process.env = originalEnv

    const provider = logs.getLoggerProvider()
    if (provider.shutdown) {
      provider.shutdown()
    }
    logs.disable()
    sinon.restore()
  })

  describe('Logs Export', () => {
    it('exports logs with complete OTLP structure, trace correlation, and instrumentation info', () => {
      mockOtlpExport((decoded, capturedHeaders) => {
        const { resource } = decoded.resourceLogs[0]
        const resourceAttrs = {}
        resource.attributes.forEach(attr => { resourceAttrs[attr.key] = attr.value.stringValue })
        assert(resourceAttrs['service.name'])

        // Validate we have 2 separate scope logs (one per instrumentation library)
        const { scopeLogs } = decoded.resourceLogs[0]
        assert.strictEqual(scopeLogs.length, 1)

        const scope = scopeLogs[0]
        assert.strictEqual(scope.scope.name, 'test-logger')
        assert.strictEqual(scope.scope.version, '1.0.0')
        assert.strictEqual(scope.schemaUrl, 'https://opentelemetry.io/schemas/1.27.0')
        assert.strictEqual(scope.logRecords.length, 2)

        const log1 = scope.logRecords[0]
        assert.strictEqual(log1.severityText, 'INFO')
        assert.strictEqual(log1.body.stringValue, 'Test message')
        assert.strictEqual(log1.traceId.toString('hex'), '1234567890abcdef1234567890abcdef')
        assert.strictEqual(log1.spanId.toString('hex'), '1234567890abcdef')

        const log2 = scope.logRecords[1]
        assertObjectContains(log2, {
          severityText: 'ERROR',
          severityNumber: 17,
          body: {
            stringValue: 'Test error message',
          },
        })
        assert.strictEqual(log2.traceId.toString('hex'), '1234567890abcdef1234567890abcdef')
        assert.strictEqual(log2.spanId.toString('hex'), '1234567890abcdef')
      })
      setupLogs(true, '2')

      const spanContext = {
        traceId: '1234567890abcdef1234567890abcdef',
        spanId: '1234567890abcdef',
        traceFlags: 1,
      }
      context.with(trace.setSpan(context.active(), trace.wrapSpanContext(spanContext)), () => {
        const logger = logs.getLogger('test-logger', '1.0.0', { schemaUrl: 'https://opentelemetry.io/schemas/1.27.0' })

        logger.emit({
          severityText: 'INFO',
          body: 'Test message',
          attributes: { 'test.key': 'test.value' },
        })
        logger.emit({
          severityText: 'ERROR',
          severityNumber: 17,
          instrumentationScope: { name: 'test-logger', version: '1.0.0' },
          body: 'Test error message',
          attributes: { 'error.array': [1, 2, 3] },
        })
      })
    })

    it('exports logs using protobuf protocol', () => {
      mockOtlpExport((decoded, capturedHeaders) => {
        assert.strictEqual(decoded.resourceLogs[0].scopeLogs[0].logRecords[0].body.stringValue, 'Protobuf format')
      })

      const { logs } = setupLogs()
      logs.getLogger({ name: 'test' }).emit({ severityText: 'INFO', body: 'Protobuf format' })
    })

    it('timestamps logs with UNIX-epoch nanoseconds', () => {
      const now = new Date('2023-11-14T22:13:20.123Z')
      sinon.useFakeTimers({ now })
      mockOtlpExport((decoded) => {
        const { timeUnixNano } = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(timeUnixNano.toString(), '1700000000123000000')
      })

      const { logs } = setupLogs()
      logs.getLogger('test').emit(Object.freeze({ body: 'Timestamp test' }))
    })

    it('normalizes timestamps before passing a cloned record to the processor', () => {
      const { logs, loggerProvider } = setupLogs()
      const onEmit = sinon.stub(loggerProvider.processor, 'onEmit')
      const timestamp = 1700000000123
      const logRecord = Object.freeze({
        body: 'Timestamp test',
        timestamp,
        observedTimestamp: new Date('2023-11-14T22:13:20.456Z'),
        attributes: Object.freeze({ key: 'value' }),
      })

      logs.getLogger('test').emit(logRecord)

      sinon.assert.calledOnce(onEmit)
      const emittedRecord = onEmit.firstCall.args[0]
      assert.notStrictEqual(emittedRecord, logRecord)
      assert.deepStrictEqual(emittedRecord.timestamp, timeInputToHrTime(timestamp))
      assert.deepStrictEqual(emittedRecord.observedTimestamp, [1700000000, 456000000])
      assert.deepStrictEqual(emittedRecord.attributes, { key: 'value' })
    })

    it('warns once when replacing invalid timestamps', () => {
      const { logs } = setupLogs()
      const log = require('../../src/log')
      const warn = sinon.stub(log, 'warn')
      const logger = logs.getLogger('test')

      logger.emit({ body: 'invalid timestamp', timestamp: null })
      logger.emit({ body: 'another invalid timestamp', timestamp: NaN })

      sinon.assert.calledOnceWithExactly(warn, 'Invalid OpenTelemetry log timestamp; using the current time instead')
    })

    for (const invalidTimestamp of [
      null,
      NaN,
      Infinity,
      new Date('invalid'),
      new Date('1960-01-01'),
      [],
      [1],
      [-1, 0],
      [1, NaN],
      [18_446_744_074, 0],
    ]) {
      it(`uses the current time for invalid timestamps: ${String(invalidTimestamp)}`, () => {
        const { logs, loggerProvider } = setupLogs()
        const onEmit = sinon.stub(loggerProvider.processor, 'onEmit')
        const logger = logs.getLogger('test')
        const now = new Date('2023-11-14T22:13:20.123Z')
        sinon.useFakeTimers({ now })

        logger.emit({ body: 'invalid timestamp', timestamp: invalidTimestamp })
        logger.emit({ body: 'invalid observed timestamp', observedTimestamp: invalidTimestamp })

        sinon.assert.calledTwice(onEmit)
        for (const emittedRecord of onEmit.args.map(args => args[0])) {
          assert.deepStrictEqual(emittedRecord.timestamp, [1700000000, 123000000])
        }
        assert.deepStrictEqual(onEmit.secondCall.args[0].observedTimestamp, [1700000000, 123000000])
      })
    }

    it('normalizes all OpenTelemetry timestamp input types without losing precision', () => {
      const numericTimestamp = 1700000000123
      const [numericSeconds, numericNanoseconds] = timeInputToHrTime(numericTimestamp)
      mockOtlpExport((decoded) => {
        const records = decoded.resourceLogs[0].scopeLogs[0].logRecords
        assert.deepStrictEqual(records.map(record => record.timeUnixNano.toString()), [
          (BigInt(numericSeconds) * 1_000_000_000n + BigInt(numericNanoseconds)).toString(),
          '1700000000456000000',
          '1700000000789123456',
        ])
        assert.strictEqual(records[0].observedTimeUnixNano.toString(), '1700000000987654321')
      })

      const { logs } = setupLogs(true, '3')
      const logger = logs.getLogger('test')
      logger.emit({
        body: 'number timestamp',
        timestamp: numericTimestamp,
        observedTimestamp: [1700000000, 987654321],
      })
      logger.emit({ body: 'date timestamp', timestamp: new Date('2023-11-14T22:13:20.456Z') })
      logger.emit({ body: 'hrtime timestamp', timestamp: [1700000000, 789123456] })
    })

    it('accepts frozen HrTime timestamps without mutating or copying them', () => {
      const { logs, loggerProvider } = setupLogs()
      const onEmit = sinon.stub(loggerProvider.processor, 'onEmit')
      const timestamp = Object.freeze([1700000000, 789123456])

      logs.getLogger('test').emit({ body: 'frozen HrTime', timestamp })

      sinon.assert.calledOnce(onEmit)
      assert.strictEqual(onEmit.firstCall.args[0].timestamp, timestamp)
    })

    it('preserves legacy numeric Unix-nanosecond timestamps', () => {
      const legacyTimestamp = 1700000000123 * 1e6
      mockOtlpExport((decoded) => {
        const { timeUnixNano } = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(timeUnixNano.toString(), BigInt(legacyTimestamp).toString())
      })

      const { logs } = setupLogs()
      logs.getLogger('test').emit({ body: 'Legacy timestamp', timestamp: legacyTimestamp })
    })

    it('matches OpenTelemetry numeric timestamp handling', () => {
      const timestamp = Date.UTC(1990, 0, 1)
      const [seconds, nanoseconds] = timeInputToHrTime(timestamp)
      mockOtlpExport((decoded) => {
        const { timeUnixNano } = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(timeUnixNano.toString(), (BigInt(seconds) * 1_000_000_000n + BigInt(nanoseconds)).toString())
      })

      const { logs } = setupLogs()
      logs.getLogger('test').emit({ body: 'Numeric timestamp', timestamp })
    })

    it('encodes exact timestamp strings using the OTLP JSON protocol', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL = 'http/json'
      mockOtlpExport((decoded) => {
        const record = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(record.timeUnixNano, '1700000000789123456')
        assert.strictEqual(record.observedTimeUnixNano, '1700000000987654321')
      }, 'json')

      const { logs } = setupLogs()
      logs.getLogger('test').emit({
        body: 'JSON timestamp test',
        timestamp: [1700000000, 789123456],
        observedTimestamp: [1700000000, 987654321],
      })
    })

    it('exports logs using JSON protocol', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL = 'http/json'
      mockOtlpExport((decoded, capturedHeaders) => {
        assert.strictEqual(decoded.resourceLogs[0].scopeLogs[0].logRecords[0].body.stringValue, 'JSON format')
      }, 'json')

      const { logs } = setupLogs()
      logs.getLogger('test').emit({ severityText: 'DEBUG', body: 'JSON format' })
    })

    it('returns no-op logger after shutdown', (done) => {
      const validator = mockOtlpExport((decoded) => {
        // Should only export the log emitted before shutdown
        assert.strictEqual(decoded.resourceLogs[0].scopeLogs[0].logRecords.length, 1)
        assert.strictEqual(decoded.resourceLogs[0].scopeLogs[0].logRecords[0].body.stringValue, 'before shutdown')
      })

      const { logs, loggerProvider } = setupLogs(true, '2')
      const logger1 = logs.getLogger('test-logger')

      // Emit before shutdown - should work
      logger1.emit({ body: 'before shutdown', attributes: {} })

      // Shutdown the provider
      loggerProvider.forceFlush()
      loggerProvider.shutdown()
      assert.strictEqual(loggerProvider.isShutdown, true)
      // Existing loggers should not send logs after shutdown
      logger1.emit({ body: 'after shutdown same logger' })

      // Get a new logger after shutdown - should be no-op
      loggerProvider.register()
      const logger2 = logs.getLogger('test-logger-2')
      logger2.emit({ body: 'after shutdown new logger' })
      loggerProvider.forceFlush()

      // Wait a bit and verify only the first log was exported
      setTimeout(() => {
        validator()
        done()
      }, 50)
    })

    it('supports instrumentationScope for compatibility', () => {
      mockOtlpExport((decoded, capturedHeaders) => {
        const log = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(log.body.stringValue, 'Scope test')
      })

      const { logs } = setupLogs()
      logs.getLogger('test-logger').emit({
        body: 'Scope test',
        instrumentationScope: { name: 'custom-scope', version: '2.0.0' },
      })
    })

    it('sends payload with expected format', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_HEADERS = 'x-api-key=test123'
      process.env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE = '1'
      process.env.DD_SERVICE = 'test-service'
      process.env.DD_VERSION = 'testversion'
      process.env.DD_ENV = 'testenv'
      process.env.DD_TAGS = 'testtag:testvalue'
      process.env.DD_TRACE_OTEL_ENABLED = 'true'

      mockOtlpExport((decoded, capturedHeaders) => {
        const actual = JSON.parse(JSON.stringify(protoLogsService.toObject(decoded, {
          longs: String,
          bytes: String,
          enums: String,
        })))
        const attrs = actual.resourceLogs[0].resource.attributes
        const runtimeId = attrs.find(a => a.key === 'runtime-id').value.stringValue
        const clientId = attrs.find(a => a.key === '_dd.rc.client_id').value.stringValue

        const expected = {
          resourceLogs: [{
            resource: {
              attributes: [
                { key: 'service.name', value: { stringValue: 'test-service' } },
                { key: 'service.version', value: { stringValue: 'testversion' } },
                { key: 'deployment.environment', value: { stringValue: 'testenv' } },
                { key: 'testtag', value: { stringValue: 'testvalue' } },
                { key: 'runtime-id', value: { stringValue: runtimeId } },
                { key: '_dd.rc.client_id', value: { stringValue: clientId } },
              ],
            },
            scopeLogs: [{
              scope: {
                name: 'test-service',
                version: '1.0.0',
              },
              logRecords: [{
                body: { stringValue: 'HTTP test message' },
                severityText: 'ERROR',
                severityNumber: 'SEVERITY_NUMBER_ERROR',
                attributes: [{ key: 'test.attr', value: { stringValue: 'value' } }],
                timeUnixNano: actual.resourceLogs[0].scopeLogs[0].logRecords[0].timeUnixNano,
                observedTimeUnixNano: actual.resourceLogs[0].scopeLogs[0].logRecords[0].observedTimeUnixNano,
                flags: 1,
                traceId: 'AAAAAAAAAAAAAAAAAAAAAQ==',
                spanId: 'AAAAAAAAAAI=',
              }],
            }],
          }],
        }

        assert.deepStrictEqual(actual, expected)

        // Validate key headers (ignore dynamic Content-Length)
        assert.strictEqual(capturedHeaders['Content-Type'], 'application/x-protobuf')
        assert.strictEqual(capturedHeaders['x-api-key'], 'test123')
      })

      setupLogsFull()

      const spanContext = {
        traceId: '00000000000000000000000000000001',
        spanId: '0000000000000002',
        traceFlags: 1,
      }
      logs.getLogger('test-service', '1.0.0').emit({
        observedTimestamp: new Date(),
        severityText: 'ERROR',
        severityNumber: 17,
        body: 'HTTP test message',
        attributes: { 'test.attr': 'value' },
        context: trace.setSpan(context.active(), trace.wrapSpanContext(spanContext)),
      })
    })

    it('groups logs by instrumentation library in separate scope payloads', () => {
      mockOtlpExport((decoded, capturedHeaders) => {
        const { resourceLogs } = decoded
        assert.strictEqual(resourceLogs.length, 1)

        const { scopeLogs } = resourceLogs[0]
        assert.strictEqual(scopeLogs.length, 2) // Should have 2 separate scope logs

        // First scope: logger1@1.0.0
        const scope1 = scopeLogs[0]
        assert.strictEqual(scope1.scope.name, 'logger1')
        assert.strictEqual(scope1.scope.version, '1.0.0')
        assert.strictEqual(scope1.logRecords.length, 1)
        assert.strictEqual(scope1.logRecords[0].severityText, 'INFO')
        assert.strictEqual(scope1.logRecords[0].body.stringValue, 'Message from logger1')

        // Second scope: logger2@2.0.0
        const scope2 = scopeLogs[1]
        assert.strictEqual(scope2.scope.name, 'logger2')
        assert.strictEqual(scope2.scope.version, '2.0.0')
        assert.strictEqual(scope2.logRecords.length, 1)
        assert.strictEqual(scope2.logRecords[0].severityText, 'ERROR')
        assert.strictEqual(scope2.logRecords[0].body.stringValue, 'Message from logger2')
      })

      setupLogs(true, '2')

      const spanContext = {
        traceId: '1234567890abcdef1234567890abcdef',
        spanId: '1234567890abcdef',
        traceFlags: 1,
      }
      context.with(trace.setSpan(context.active(), trace.wrapSpanContext(spanContext)), () => {
        const logger1 = logs.getLogger({ name: 'logger1', version: '1.0.0' })
        const logger2 = logs.getLogger('logger2', '2.0.0')

        logger1.emit({
          severityText: 'INFO',
          body: 'Message from logger1',
          attributes: { logger: 'logger1' },
        })

        logger2.emit({
          severityText: 'ERROR',
          body: 'Message from logger2',
          attributes: { logger: 'logger2' },
        })
      })
    })

    it('handles invalid severity number by defaulting to INFO', (done) => {
      mockOtlpExport((decoded) => {
        const logRecord = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        // Invalid severity number should default to INFO (9)
        assert.strictEqual(logRecord.severityNumber, 9)
        done()
      })

      const { logs } = setupLogs()
      const logger = logs.getLogger('test-logger')

      // Emit with an invalid severity number (999)
      logger.emit({
        // @ts-expect-error - check invalid severity number
        severityNumber: 999,
        body: 'Test message with invalid severity',
      })
    })

    it('transforms different body types correctly', (done) => {
      mockOtlpExport((decoded) => {
        const logRecords = decoded.resourceLogs[0].scopeLogs[0].logRecords

        // String body
        assert.strictEqual(logRecords[0].body.stringValue, 'string message')

        // Integer body (protobuf returns Long objects for int64)
        const intValue = logRecords[1].body.intValue
        assert.strictEqual(intValue !== null && typeof intValue === 'object' ? intValue.toNumber() : intValue, 42)

        // Double/float body
        assert.notStrictEqual(logRecords[2].body.doubleValue, undefined)
        assert(
          Math.abs(logRecords[2].body.doubleValue - 3.14159) < 0.00001,
          `Expected ${Math.abs(logRecords[2].body.doubleValue - 3.14159)} < 0.00001`
        )

        // Boolean body
        assert.strictEqual(logRecords[3].body.boolValue, true)

        // Object body - tests Object.entries().map() transformation
        assert(logRecords[4].body.kvlistValue)
        assert.strictEqual(logRecords[4].body.kvlistValue.values.length, 2)
        assert.strictEqual(logRecords[4].body.kvlistValue.values[0].key, 'foo')
        assert.strictEqual(logRecords[4].body.kvlistValue.values[0].value.stringValue, 'bar')
        assert.strictEqual(logRecords[4].body.kvlistValue.values[1].key, 'baz')
        const bazValue = logRecords[4].body.kvlistValue.values[1].value.intValue
        assert.strictEqual(bazValue !== null && typeof bazValue === 'object' ? bazValue.toNumber() : bazValue, 123)

        // Default case (symbol) - should convert to string
        assert.strictEqual(logRecords[5].body.stringValue, 'Symbol(test)')

        done()
      })

      const { logs } = setupLogs(true, '6')
      const logger = logs.getLogger('test-logger')

      // Emit logs with different body types
      logger.emit({ body: 'string message' })
      logger.emit({ body: 42 })
      logger.emit({ body: 3.14159 })
      logger.emit({ body: true })
      logger.emit({ body: { foo: 'bar', baz: 123 } })
      logger.emit({ body: Symbol('test') })
    })

    it('sends logs after batch timeout expires', (done) => {
      mockOtlpExport((decoded) => {
        const logRecord = decoded.resourceLogs[0].scopeLogs[0].logRecords[0]
        assert.strictEqual(logRecord.body.stringValue, 'timeout test')
        done()
      })

      process.env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE = '10'
      process.env.OTEL_BSP_SCHEDULE_DELAY = '100' // 100ms timeout

      const { logs } = setupLogs()
      const logger = logs.getLogger('test-logger')

      logger.emit({ body: 'timeout test' })

      // Wait 100ms to ensure timer fires
      setTimeout(() => {}, 100)
    })

    it('exports resource with service, version, env, and hostname', (done) => {
      mockOtlpExport((decoded) => {
        const resource = decoded.resourceLogs[0].resource
        const resourceAttrs = {}
        resource.attributes.forEach(attr => { resourceAttrs[attr.key] = attr.value.stringValue })

        assertObjectContains(resourceAttrs, {
          'service.name': 'my-service',
          'service.version': 'v1.2.3',
          'deployment.environment': 'production',
          'host.name': os.hostname(),
        })
        done()
      })

      process.env.DD_SERVICE = 'my-service'
      process.env.DD_VERSION = 'v1.2.3'
      process.env.DD_ENV = 'production'
      process.env.DD_TRACE_REPORT_HOSTNAME = 'true'

      const { logs } = setupLogs()
      const logger = logs.getLogger('test-logger')
      logger.emit({ body: 'test' })
    })

    it('handles multiple register() calls', () => {
      const { logs, loggerProvider } = setupLogs()

      // Calling register again should not throw
      loggerProvider.register()

      // Provider should still work
      assert.strictEqual(logs.getLoggerProvider(), loggerProvider)
      logs.getLogger('test').emit({ body: 'test' })
    })
  })

  describe('Configurations', () => {
    it('uses default protobuf protocol', () => {
      delete process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL
      delete process.env.OTEL_EXPORTER_OTLP_PROTOCOL
      const { loggerProvider } = setupLogs()
      assert(loggerProvider.processor)
      assert.strictEqual(loggerProvider.processor.exporter.transformer.protocol, 'http/protobuf')
    })

    it('configures protocol from environment variable', () => {
      process.env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/json'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.transformer.protocol, 'http/json')
    })

    it('prioritizes logs-specific protocol over generic protocol', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL = 'http/json'
      process.env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/protobuf'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.transformer.protocol, 'http/json')
    })

    it('warns and falls back to protobuf when gRPC protocol is set', () => {
      const logMock = mockLogWarn()
      process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL = 'grpc'

      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.transformer.protocol, 'http/protobuf')
      assert.match(logMock.getMessage(), /OTLP gRPC protocol is not supported/)

      logMock.restore()
    })

    it('configures OTLP endpoint from environment variable', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = 'http://custom:4321/v1/logs'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.path, '/v1/logs')
      assert.strictEqual(loggerProvider.processor.exporter.options.hostname, 'custom')
      assert.strictEqual(loggerProvider.processor.exporter.options.port, '4321')
    })

    it('prioritizes logs-specific endpoint over generic endpoint', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = 'http://custom:4318/v1/logs'
      process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://generic:4318/v1/logs'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.path, '/v1/logs')
      assert.strictEqual(loggerProvider.processor.exporter.options.hostname, 'custom')
      assert.strictEqual(loggerProvider.processor.exporter.options.port, '4318')
    })

    it('appends /v1/logs when deriving the URL from the generic OTEL_EXPORTER_OTLP_ENDPOINT', () => {
      process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://custom:4318'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.path, '/v1/logs')
    })

    it('uses a signal-specific endpoint as-is without appending /v1/logs', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = 'http://custom:4318'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.path, '/')
    })

    it('configures OTLP headers from environment variable', () => {
      process.env.OTEL_EXPORTER_OTLP_HEADERS = 'api-key=secret,env=prod'
      const { loggerProvider } = setupLogs()
      const exporter = loggerProvider.processor.exporter
      assert.strictEqual(exporter.options.headers['api-key'], 'secret')
      assert.strictEqual(exporter.options.headers.env, 'prod')
    })

    it('prioritizes logs-specific headers over generic OTLP headers', () => {
      process.env.OTEL_EXPORTER_OTLP_HEADERS = 'generic=value,shared=generic'
      process.env.OTEL_EXPORTER_OTLP_LOGS_HEADERS = 'logs-specific=value,shared=logs'
      const { loggerProvider } = setupLogs()
      const exporter = loggerProvider.processor.exporter
      assert.strictEqual(exporter.options.headers['logs-specific'], 'value')
      assert.strictEqual(exporter.options.headers.shared, 'logs')
      assert.strictEqual(exporter.options.headers.generic, undefined)
    })

    it('configures OTLP timeout from environment variable', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_TIMEOUT = '1000'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.timeout, 1000)
    })

    it('prioritizes logs-specific timeout over generic timeout', () => {
      process.env.OTEL_EXPORTER_OTLP_LOGS_TIMEOUT = '1000'
      process.env.OTEL_EXPORTER_OTLP_TIMEOUT = '2000'
      const { loggerProvider } = setupLogs()
      assert.strictEqual(loggerProvider.processor.exporter.options.timeout, 1000)
    })

    it('does not initialize when OTEL logs are disabled', () => {
      const { loggerProvider } = setupLogs(false)
      const { LoggerProvider } = require('../../src/opentelemetry/logs')

      // Should return no-op provider when disabled, not our custom LoggerProvider
      assert.strictEqual(loggerProvider instanceof LoggerProvider, false)
    })

    it('disables log injection when OTEL logs are enabled', () => {
      const { config, loggerProvider } = setupLogs()

      assert(loggerProvider)
      assert.strictEqual(config.logInjection, false)
    })

    it('disables log injection even when DD_LOGS_INJECTION is explicitly set to true', () => {
      // OTEL logs and DD log injection are mutually exclusive
      process.env.DD_LOGS_INJECTION = 'true'
      const { config, loggerProvider } = setupLogs()

      assert(loggerProvider)
      assert.strictEqual(config.logInjection, false)
    })
  })

  describe('Telemetry Metrics', () => {
    it('tracks telemetry metrics for exported logs', () => {
      setupLogs()
      const telemetryMetrics = {
        manager: { namespace: sinon.stub().returns({ count: sinon.stub().returns({ inc: sinon.spy() }) }) },
      }
      const MockedExporter = proxyquire('../../src/opentelemetry/logs/otlp_http_log_exporter', {
        '../otlp/otlp_http_exporter_base': proxyquire('../../src/opentelemetry/otlp/otlp_http_exporter_base', {
          '../../telemetry/metrics': telemetryMetrics,
        }),
      })

      const exporter = new MockedExporter('http://localhost:4318/v1/logs', '', 1000, 'http/protobuf', {})
      exporter.export([{ body: 'test', severityNumber: 9, timestamp: [1700000000, 0] }], () => {})

      assert(telemetryMetrics.manager.namespace().count().inc.calledWith(1))
    })
  })
})