@smoothbricks/lmao 0.1.0

package/src/lib/codegen/__tests__/nullBitmap.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Unit tests for null bitmap correctness in SpanLogger code generation
+ *
+ * These tests verify that the generated code sets null bitmap bits correctly
+ * for single writes and log entries with scoped attributes.
+ *
+ * Architecture changes (new design):
+ * - SpanLogger handles log entries (rows 2+), NOT tag writes (row 0)
+ * - Tag writing is done via ctx.tag which is a separate API (not on SpanLogger)
+ * - SpanLogger constructor: (buffer, createNextBuffer)
+ * - SpanLogger._writeIndex starts at 1 (rows 0/1 are reserved for span-start/end)
+ * - _setScope() stores scope values in buffer._scopeValues (immutable, frozen)
+ * - Scope filling happens at Arrow conversion time, NOT during span execution
+ * - Direct writes (tag/log) win over scope values on their respective rows
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { createBuffer, createTestTraceRoot } from '../../__tests__/test-helpers.js';
+import { DEFAULT_METADATA } from '../../opContext/defineOp.js';
+import { S } from '../../schema/builder.js';
+import { defineLogSchema } from '../../schema/defineLogSchema.js';
+import type { LogSchema } from '../../schema/types.js';
+import { createSpanBuffer, SpanBufferTestUtils } from '../../spanBuffer.js';
+
+import type { AnySpanBuffer } from '../../types.js';
+import { createSpanLoggerClass } from '../spanLoggerGenerator.js';
+
+/**
+ * Create a test buffer from a schema
+ */
+function createTestBuffer(schema: LogSchema): AnySpanBuffer {
+  return createBuffer(schema);
+}
+
+/**
+ * Create a test buffer with a specific capacity
+ */
+function createTestBufferWithCapacity(schema: LogSchema, capacity: number): AnySpanBuffer {
+  return createSpanBuffer(schema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
+}
+
+describe('null bitmap correctness', () => {
+  describe('immutable scope semantics', () => {
+    it('should store scope values in buffer._scopeValues as frozen object', () => {
+      const schema = defineLogSchema({
+        requestId: S.category(),
+      });
+      const buffer = createTestBuffer(schema);
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // _setScope should store values in buffer._scopeValues (not fill buffer columns)
+      logger._setScope({ requestId: 'req-123' });
+
+      // Verify scope values are stored in buffer._scopeValues
+      expect(buffer._scopeValues).toBeDefined();
+      expect(buffer._scopeValues?.requestId).toBe('req-123');
+
+      // Verify the object is frozen (immutable)
+      expect(Object.isFrozen(buffer._scopeValues)).toBe(true);
+    });
+
+    it('should create new frozen object on each _setScope call (merge semantics)', () => {
+      const schema = defineLogSchema({
+        requestId: S.category(),
+        userId: S.category(),
+      });
+      const buffer = createTestBuffer(schema);
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // First setScope call
+      logger._setScope({ requestId: 'req-123' });
+      const firstScopeValues = buffer._scopeValues;
+      expect(firstScopeValues?.requestId).toBe('req-123');
+      expect(firstScopeValues?.userId).toBeUndefined();
+
+      // Second setScope call - should merge with existing values
+      logger._setScope({ userId: 'user-456' });
+      const secondScopeValues = buffer._scopeValues;
+
+      // Should be a NEW object (immutable semantics)
+      expect(secondScopeValues).not.toBe(firstScopeValues);
+
+      // Should have merged values
+      expect(secondScopeValues?.requestId).toBe('req-123');
+      expect(secondScopeValues?.userId).toBe('user-456');
+
+      // Both should be frozen
+      expect(Object.isFrozen(firstScopeValues)).toBe(true);
+      expect(Object.isFrozen(secondScopeValues)).toBe(true);
+    });
+
+    it('should clear keys when null is passed (null clears, undefined ignores)', () => {
+      const schema = defineLogSchema({
+        requestId: S.category(),
+        userId: S.category(),
+      });
+      const buffer = createTestBuffer(schema);
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // Set initial values
+      logger._setScope({ requestId: 'req-123', userId: 'user-456' });
+      expect(buffer._scopeValues?.requestId).toBe('req-123');
+      expect(buffer._scopeValues?.userId).toBe('user-456');
+
+      // Pass null to clear requestId, undefined should be ignored
+      logger._setScope({ requestId: null, userId: undefined });
+
+      // requestId should be cleared (null), userId should remain (undefined ignored)
+      expect(buffer._scopeValues?.requestId).toBeUndefined();
+      expect(buffer._scopeValues?.userId).toBe('user-456');
+    });
+
+    it('should NOT fill buffer columns during _setScope (deferred to Arrow conversion)', () => {
+      const schema = defineLogSchema({
+        requestId: S.category(),
+      });
+      const buffer = createTestBuffer(schema);
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // _setScope should NOT fill buffer columns
+      logger._setScope({ requestId: 'req-123' });
+
+      // Check null bitmap - should NOT be allocated (lazy allocation on first write)
+      const nulls = SpanBufferTestUtils.getNullBitmap(buffer, 'requestId');
+
+      // Null bitmap should NOT be allocated since we never directly wrote to requestId
+      // Scope filling happens at Arrow conversion time, not during span execution
+      expect(nulls).toBeUndefined();
+    });
+  });
+
+  describe('log message writes (arbitrary index)', () => {
+    it('should NOT set null bitmap during info() - scope filling is deferred to Arrow conversion', () => {
+      // Per specs/lmao/01i_span_scope_attributes.md:
+      // - Scope values are stored in buffer._scopeValues as a plain object
+      // - Scope filling happens at Arrow conversion time, NOT during span execution
+      // - This is because scope values are "defaults" that fill null slots
+      const schema = defineLogSchema({
+        requestId: S.category(),
+      });
+      const buffer = createTestBuffer(schema);
+
+      // Set scope value via buffer._scopeValues directly for test setup
+      buffer._scopeValues = Object.freeze({ requestId: 'req-123' });
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // Set _writeIndex to 4 so nextRow() makes it 5
+      logger._writeIndex = 4;
+
+      // Log a message - this does NOT write scoped attributes during execution
+      // Scope values are filled at Arrow conversion time
+      logger.info('test message');
+
+      // Verify that the null bitmap bit is NOT set (scope is deferred)
+      const nulls = SpanBufferTestUtils.getNullBitmap(buffer, 'requestId');
+      // Null bitmap might not even be allocated since we never directly wrote to requestId
+      if (nulls) {
+        // If allocated, the bits should be 0 (not written directly)
+        expect(nulls[0] & (1 << 5)).toBe(0);
+      }
+    });
+
+    it('should NOT set null bitmap at index 9 during info() - scope is deferred', () => {
+      // Same as above - scope values are NOT written during span execution
+      // They are stored in buffer._scopeValues and filled at Arrow conversion
+      const schema = defineLogSchema({
+        requestId: S.category(),
+      });
+      // Need capacity > 9 to test writing at index 9
+      const buffer = createTestBufferWithCapacity(schema, 16);
+
+      // Set scope value via buffer._scopeValues directly for test setup
+      buffer._scopeValues = Object.freeze({ requestId: 'req-456' });
+
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+      const logger = new SpanLoggerClass(buffer);
+
+      // Set _writeIndex to 8 so nextRow() makes it 9
+      logger._writeIndex = 8;
+
+      // Log a message - does NOT write scoped attributes immediately
+      logger.info('test message');
+
+      // Verify scope values are stored correctly
+      expect(buffer._scopeValues.requestId).toBe('req-456');
+
+      // Null bitmap is not set during execution (deferred to Arrow conversion)
+      const nulls = SpanBufferTestUtils.getNullBitmap(buffer, 'requestId');
+      if (nulls) {
+        const byteIndex = 9 >>> 3; // = 1
+        const bitOffset = 9 & 7; // = 1
+        // Not set - scope filling is deferred
+        expect(nulls[byteIndex] & (1 << bitOffset)).toBe(0);
+      }
+    });
+  });
+});

package/src/lib/codegen/__tests__/spanLoggerGenerator.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Unit tests for SpanLogger code generation
+ *
+ * SpanLogger extends ColumnWriter from arrow-builder and adds:
+ * - info(), debug(), warn(), error() methods for log entries
+ * - _setScope() for setting scoped attributes
+ * - _getNextBuffer() override for SpanBuffer creation on overflow
+ *
+ * Note: Tag writing (row 0) is handled by TagWriter (not yet implemented).
+ * SpanLogger only handles log entries (rows 2+).
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { createTestLogger } from '../../__tests__/test-helpers.js';
+import { S } from '../../schema/builder.js';
+import { defineLogSchema } from '../../schema/defineLogSchema.js';
+import {
+  ENTRY_TYPE_DEBUG,
+  ENTRY_TYPE_ERROR,
+  ENTRY_TYPE_INFO,
+  ENTRY_TYPE_TRACE,
+  ENTRY_TYPE_WARN,
+} from '../../schema/systemSchema.js';
+import { createSpanLoggerClass } from '../spanLoggerGenerator.js';
+
+describe('createSpanLoggerClass', () => {
+  describe('class creation', () => {
+    it('should create a SpanLogger class for empty schema', () => {
+      const schema = defineLogSchema({});
+      const SpanLoggerClass = createSpanLoggerClass(schema);
+
+      expect(SpanLoggerClass).toBeDefined();
+      expect(typeof SpanLoggerClass).toBe('function');
+    });
+
+    it('should cache generated classes for the same schema', () => {
+      const schema = defineLogSchema({
+        userId: S.category(),
+      });
+
+      const Class1 = createSpanLoggerClass(schema);
+      const Class2 = createSpanLoggerClass(schema);
+
+      expect(Class1).toBe(Class2);
+    });
+
+    it('should create different classes for different schemas', () => {
+      const schema1 = defineLogSchema({ userId: S.category() });
+      const schema2 = defineLogSchema({ requestId: S.category() });
+
+      const Class1 = createSpanLoggerClass(schema1);
+      const Class2 = createSpanLoggerClass(schema2);
+
+      expect(Class1).not.toBe(Class2);
+    });
+  });
+
+  describe('instance creation', () => {
+    it('should create instance with buffer and createNextBuffer', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { buffer, logger } = createTestLogger(schema);
+
+      expect(logger).toBeDefined();
+      expect(logger._buffer).toBe(buffer);
+      expect(buffer._scopeValues).toBeDefined();
+    });
+
+    it('should start with _writeIndex = 1', () => {
+      const schema = defineLogSchema({});
+      const { logger } = createTestLogger(schema);
+
+      expect(logger._writeIndex).toBe(1);
+    });
+  });
+
+  describe('logging methods', () => {
+    it('should increment _writeIndex on info()', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { logger } = createTestLogger(schema);
+
+      expect(logger._writeIndex).toBe(1);
+      logger.info('Test message');
+      expect(logger._writeIndex).toBe(2);
+    });
+
+    it('should write entry type for info()', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.info('Test message');
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_INFO);
+    });
+
+    it('should write entry type for debug()', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.debug('Debug message');
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_DEBUG);
+    });
+
+    it('should write entry type for warn()', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.warn('Warning message');
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_WARN);
+    });
+
+    it('should write entry type for error()', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.error('Error message');
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_ERROR);
+    });
+
+    it('should write entry type for trace()', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.trace('Trace message');
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_TRACE);
+    });
+
+    it('should write timestamp for log entries', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.info('Test message');
+
+      expect(buffer.timestamp[2]).not.toBe(0n);
+      expect(typeof buffer.timestamp[2]).toBe('bigint');
+    });
+
+    it('should return this for fluent chaining', () => {
+      const schema = defineLogSchema({});
+      const { logger } = createTestLogger(schema);
+
+      const result = logger.info('Test message');
+
+      // FluentLogEntry is same object at runtime (types differ but object identity is same)
+      expect(result === (logger as unknown)).toBe(true);
+    });
+
+    it('should support chaining logging methods', () => {
+      const schema = defineLogSchema({});
+      const { buffer, logger } = createTestLogger(schema);
+
+      // FluentLogEntry includes logging methods for continued chaining
+      logger.info('First').info('Second').warn('Third');
+
+      expect(logger._writeIndex).toBe(4);
+      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_INFO);
+      expect(buffer.entry_type[3]).toBe(ENTRY_TYPE_INFO);
+      expect(buffer.entry_type[4]).toBe(ENTRY_TYPE_WARN);
+    });
+  });
+
+  describe('scope management', () => {
+    it('should update scope values via _setScope to buffer._scopeValues', () => {
+      const schema = defineLogSchema({
+        userId: S.category(),
+        requestId: S.category(),
+      });
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger._setScope({ userId: 'user123' });
+
+      expect(buffer._scopeValues?.userId).toBe('user123');
+      expect(buffer._scopeValues?.requestId).toBeUndefined();
+    });
+
+    it('should access scope via logger.scope getter', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { logger } = createTestLogger(schema);
+
+      logger._setScope({ userId: 'test123' });
+
+      expect(logger.scope?.userId).toBe('test123');
+    });
+  });
+
+  describe('fluent attribute setters', () => {
+    it('should have attribute setter methods from ColumnWriter', () => {
+      const schema = defineLogSchema({
+        userId: S.category(),
+        count: S.number(),
+        enabled: S.boolean(),
+      });
+      const { logger } = createTestLogger(schema);
+
+      // Log an entry first to advance writeIndex
+      logger.info('Test');
+
+      // Verify methods exist and are callable - types come from ColumnWriter<T>
+      expect(typeof logger.userId).toBe('function');
+      expect(typeof logger.count).toBe('function');
+      expect(typeof logger.enabled).toBe('function');
+    });
+
+    it('should write attribute values at current _writeIndex', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { buffer, logger } = createTestLogger(schema);
+
+      // Log an entry and chain attribute
+      logger.info('Test').userId('user123');
+
+      // Value should be at index 2 (after info() incremented from 1 to 2)
+      expect(buffer.userId_values[2]).toBe('user123');
+    });
+
+    it('should support fluent chaining with attributes', () => {
+      const schema = defineLogSchema({
+        userId: S.category(),
+        count: S.number(),
+      });
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.info('Test').userId('user123').count(42);
+
+      expect(buffer.userId_values[2]).toBe('user123');
+      expect(buffer.count_values[2]).toBe(42);
+    });
+
+    it('should write multiple log entries with different attributes', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { buffer, logger } = createTestLogger(schema);
+
+      logger.info('First').userId('user1');
+      logger.info('Second').userId('user2');
+
+      expect(buffer.userId_values[2]).toBe('user1');
+      expect(buffer.userId_values[3]).toBe('user2');
+    });
+  });
+});