@gokiteam/goki-dev 0.2.0

package/src/emulation/logging/Logic.js

@@ -0,0 +1,416 @@
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { v4 as uuidv4 } from 'uuid'
+import { Logger } from '../../singletons/Logger.js'
+import { LogBroadcaster } from '../../singletons/LogBroadcaster.js'
+
+const COLLECTION_ENTRIES = 'logging_entries'
+const COLLECTION_LOGS = 'logging_logs'
+
+/**
+ * Parse filter string to extract conditions
+ * Basic implementation supporting common filters:
+ * - logName="projects/my-project/logs/my-log"
+ * - severity>=ERROR
+ * - timestamp>"2026-02-06T00:00:00Z"
+ * - labels.key="value"
+ */
+const parseFilter = (filterString) => {
+  if (!filterString) return {}
+
+  const conditions = {}
+
+  // Extract logName filter
+  const logNameMatch = filterString.match(/logName="([^"]+)"/)
+  if (logNameMatch) {
+    conditions.logName = logNameMatch[1]
+  }
+
+  // Extract severity filter
+  const severityMatch = filterString.match(/severity(>=|>|=|<=|<)"?([^"\s]+)"?/)
+  if (severityMatch) {
+    conditions.severity = {
+      operator: severityMatch[1],
+      value: severityMatch[2]
+    }
+  }
+
+  // Extract timestamp filter
+  const timestampMatch = filterString.match(/timestamp(>=|>|=|<=|<)"([^"]+)"/)
+  if (timestampMatch) {
+    conditions.timestamp = {
+      operator: timestampMatch[1],
+      value: timestampMatch[2]
+    }
+  }
+
+  // Extract label filters
+  const labelMatches = filterString.matchAll(/labels\.(\w+)="([^"]+)"/g)
+  conditions.labels = {}
+  for (const match of labelMatches) {
+    conditions.labels[match[1]] = match[2]
+  }
+
+  return conditions
+}
+
+/**
+ * Apply filter conditions to an entry
+ */
+const matchesFilter = (entry, conditions) => {
+  // Match logName
+  if (conditions.logName && entry.logName !== conditions.logName) {
+    return false
+  }
+
+  // Match severity
+  if (conditions.severity) {
+    const severityLevels = ['DEFAULT', 'DEBUG', 'INFO', 'NOTICE', 'WARNING', 'ERROR', 'CRITICAL', 'ALERT', 'EMERGENCY']
+    const entrySeverityIndex = severityLevels.indexOf(entry.severity || 'DEFAULT')
+    const filterSeverityIndex = severityLevels.indexOf(conditions.severity.value)
+
+    switch (conditions.severity.operator) {
+      case '>=':
+        if (entrySeverityIndex < filterSeverityIndex) return false
+        break
+      case '>':
+        if (entrySeverityIndex <= filterSeverityIndex) return false
+        break
+      case '=':
+        if (entrySeverityIndex !== filterSeverityIndex) return false
+        break
+      case '<=':
+        if (entrySeverityIndex > filterSeverityIndex) return false
+        break
+      case '<':
+        if (entrySeverityIndex >= filterSeverityIndex) return false
+        break
+    }
+  }
+
+  // Match timestamp
+  if (conditions.timestamp) {
+    const entryTime = new Date(entry.timestamp).getTime()
+    const filterTime = new Date(conditions.timestamp.value).getTime()
+
+    switch (conditions.timestamp.operator) {
+      case '>=':
+        if (entryTime < filterTime) return false
+        break
+      case '>':
+        if (entryTime <= filterTime) return false
+        break
+      case '=':
+        if (entryTime !== filterTime) return false
+        break
+      case '<=':
+        if (entryTime > filterTime) return false
+        break
+      case '<':
+        if (entryTime >= filterTime) return false
+        break
+    }
+  }
+
+  // Match labels
+  if (conditions.labels && Object.keys(conditions.labels).length > 0) {
+    if (!entry.labels) return false
+    for (const [key, value] of Object.entries(conditions.labels)) {
+      if (entry.labels[key] !== value) return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Generate page token
+ */
+const generatePageToken = (offset) => {
+  return Buffer.from(JSON.stringify({ offset })).toString('base64')
+}
+
+/**
+ * Parse page token
+ */
+const parsePageToken = (token) => {
+  try {
+    const decoded = Buffer.from(token, 'base64').toString('utf8')
+    return JSON.parse(decoded)
+  } catch {
+    return { offset: 0 }
+  }
+}
+
+export const Logic = {
+  /**
+   * Write log entries
+   */
+  async writeEntries (params) {
+    const { traceId, logName, resource, labels, entries, partialSuccess, dryRun } = params
+
+    Logger.log({
+      level: 'debug',
+      message: 'Writing log entries',
+      data: { traceId, logName, entriesCount: entries.length, dryRun }
+    })
+
+    if (dryRun) {
+      return {}
+    }
+
+    const now = new Date().toISOString()
+    const storedEntries = []
+
+    for (const entry of entries) {
+      // Merge entry with top-level fields
+      const logEntry = {
+        ...entry,
+        logName: entry.logName || logName,
+        resource: entry.resource || resource,
+        labels: { ...labels, ...entry.labels },
+        insertId: entry.insertId || uuidv4(),
+        timestamp: entry.timestamp || now,
+        receiveTimestamp: now,
+        // Add internal fields
+        _id: uuidv4(),
+        createdAt: now
+      }
+
+      // Extract nested fields from jsonPayload at write time
+      const payload = logEntry.jsonPayload
+      const json = typeof payload === 'string'
+        ? (() => { try { return JSON.parse(payload) } catch { return null } })()
+        : payload
+      if (json) {
+        // Stack trace
+        if (!logEntry.stackTrace) {
+          const stack = json.error?.stack || json.stack || json.exception?.stack
+          if (stack && typeof stack === 'string') logEntry.stackTrace = stack
+        }
+        // Error message
+        if (!logEntry.errorMessage) {
+          const errMsg = json.error?.message || json.exception?.message
+          if (errMsg) logEntry.errorMessage = errMsg
+        }
+        // Event (LogEvent enum)
+        if (!logEntry.event && json.event) logEntry.event = json.event
+        // Duration
+        if (logEntry.duration === undefined && json.duration !== undefined) {
+          logEntry.duration = Number(json.duration) || null
+        }
+        // @gokiteam/oops error.data fields
+        const errorData = json.error?.data
+        if (errorData && typeof errorData === 'object') {
+          if (!logEntry.errorCode && errorData.code) logEntry.errorCode = String(errorData.code)
+          if (!logEntry.errorStatus && errorData.status) logEntry.errorStatus = errorData.status
+          if (!logEntry.errorReason && errorData.reason) logEntry.errorReason = errorData.reason
+          if (!logEntry.errorResource && errorData.resource) logEntry.errorResource = errorData.resource
+          // Entity IDs from error.data.meta
+          const meta = errorData.meta
+          if (meta && typeof meta === 'object') {
+            if (!logEntry.propertyId && meta.propertyId) logEntry.propertyId = meta.propertyId
+            if (!logEntry.deviceId && meta.deviceId) logEntry.deviceId = meta.deviceId
+            if (!logEntry.doorId && meta.doorId) logEntry.doorId = meta.doorId
+          }
+        }
+        // Pub/Sub subscriber fields
+        if (!logEntry.subscriptionName && json.subscriptionName) logEntry.subscriptionName = json.subscriptionName
+        if (!logEntry.messageId && json.messageId) logEntry.messageId = json.messageId
+        // Domain entity IDs (top-level)
+        if (!logEntry.propertyId && json.propertyId) logEntry.propertyId = json.propertyId
+        if (!logEntry.deviceId && json.deviceId) logEntry.deviceId = json.deviceId
+        if (!logEntry.doorId && json.doorId) logEntry.doorId = json.doorId
+        // Trace ID (Goki services send traceId inside jsonPayload)
+        if (!logEntry.trace && json.traceId) logEntry.trace = json.traceId
+      }
+
+      // Store entry
+      SqliteStore.create(COLLECTION_ENTRIES, logEntry)
+      LogBroadcaster.broadcast(logEntry)
+      storedEntries.push(logEntry)
+
+      // Update logs collection (track unique log names)
+      const logNameParts = logEntry.logName.match(/^projects\/([^/]+)\/logs\/(.+)$/)
+      if (logNameParts) {
+        const [, projectId, logId] = logNameParts
+        const existingLog = SqliteStore.find(
+          COLLECTION_LOGS,
+          log => log.projectId === projectId && log.logId === logId
+        )[0]
+
+        if (!existingLog) {
+          SqliteStore.create(COLLECTION_LOGS, {
+            _id: uuidv4(),
+            projectId,
+            logId,
+            logName: logEntry.logName,
+            createdAt: now,
+            updatedAt: now
+          })
+        } else {
+          SqliteStore.update(COLLECTION_LOGS, existingLog.Id, {
+            updatedAt: now
+          }, '_id')
+        }
+      }
+    }
+
+    Logger.log({
+      level: 'info',
+      message: 'Log entries written successfully',
+      data: { traceId, entriesCount: storedEntries.length }
+    })
+
+    return {}
+  },
+
+  /**
+   * List log entries with filtering and pagination
+   */
+  async listEntries (params) {
+    const { traceId, resourceNames, filter, orderBy, pageSize = 50, pageToken } = params
+
+    Logger.log({
+      level: 'debug',
+      message: 'Listing log entries',
+      data: { traceId, filter, pageSize }
+    })
+
+    // Parse page token
+    const { offset = 0 } = pageToken ? parsePageToken(pageToken) : {}
+
+    // Parse filter
+    const conditions = parseFilter(filter)
+
+    // Filter entries
+    const filteredEntries = SqliteStore.find(COLLECTION_ENTRIES, entry => {
+      // Filter by resource names
+      if (resourceNames && resourceNames.length > 0) {
+        const entryResourceName = `projects/${entry.logName.split('/')[1]}`
+        if (!resourceNames.includes(entryResourceName)) return false
+      }
+
+      // Apply filter conditions
+      return matchesFilter(entry, conditions)
+    })
+
+    // Sort entries
+    const isDescending = orderBy === 'timestamp desc' || !orderBy
+    filteredEntries.sort((a, b) => {
+      const timeA = new Date(a.timestamp).getTime()
+      const timeB = new Date(b.timestamp).getTime()
+      return isDescending ? timeB - timeA : timeA - timeB
+    })
+
+    // Paginate
+    const total = filteredEntries.length
+    const paginatedEntries = filteredEntries.slice(offset, offset + pageSize)
+    const hasMore = offset + pageSize < total
+
+    // Generate next page token
+    const nextPageToken = hasMore ? generatePageToken(offset + pageSize) : undefined
+
+    // Remove internal fields from response
+    const entries = paginatedEntries.map(entry => {
+      const { _id, _createdAt, ...publicEntry } = entry
+      return publicEntry
+    })
+
+    Logger.log({
+      level: 'info',
+      message: 'Log entries listed successfully',
+      data: { traceId, entriesCount: entries.length, total, hasMore }
+    })
+
+    return {
+      entries,
+      nextPageToken
+    }
+  },
+
+  /**
+   * List all logs for a project
+   */
+  async listLogs (params) {
+    const { traceId, project, pageSize = 50, pageToken } = params
+
+    Logger.log({
+      level: 'debug',
+      message: 'Listing logs',
+      data: { traceId, project, pageSize }
+    })
+
+    // Parse page token
+    const { offset = 0 } = pageToken ? parsePageToken(pageToken) : {}
+
+    // Find logs for project
+    const logs = SqliteStore.find(COLLECTION_LOGS, log => log.projectId === project)
+
+    // Sort by creation time
+    logs.sort((a, b) => new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime())
+
+    // Paginate
+    const total = logs.length
+    const paginatedLogs = logs.slice(offset, offset + pageSize)
+    const hasMore = offset + pageSize < total
+
+    // Generate next page token
+    const nextPageToken = hasMore ? generatePageToken(offset + pageSize) : undefined
+
+    // Return log names only
+    const logNames = paginatedLogs.map(log => log.logName)
+
+    Logger.log({
+      level: 'info',
+      message: 'Logs listed successfully',
+      data: { traceId, logsCount: logNames.length, total, hasMore }
+    })
+
+    return {
+      logNames,
+      nextPageToken
+    }
+  },
+
+  /**
+   * Delete a log and all its entries
+   */
+  async deleteLog (params) {
+    const { traceId, project, logId } = params
+
+    Logger.log({
+      level: 'debug',
+      message: 'Deleting log',
+      data: { traceId, project, logId }
+    })
+
+    const logName = `projects/${project}/logs/${logId}`
+
+    // Find and delete log metadata
+    const log = SqliteStore.find(
+      COLLECTION_LOGS,
+      log => log.projectId === project && log.logId === logId
+    )[0]
+
+    if (log) {
+      SqliteStore.delete(COLLECTION_LOGS, log.Id, '_id')
+    }
+
+    // Delete all entries for this log
+    const entries = SqliteStore.find(COLLECTION_ENTRIES, entry => entry.logName === logName)
+    let deletedCount = 0
+
+    for (const entry of entries) {
+      SqliteStore.delete(COLLECTION_ENTRIES, entry.Id, '_id')
+      deletedCount++
+    }
+
+    Logger.log({
+      level: 'info',
+      message: 'Log deleted successfully',
+      data: { traceId, project, logId, deletedEntriesCount: deletedCount }
+    })
+
+    return {}
+  }
+}

package/src/emulation/logging/Router.js

@@ -0,0 +1,36 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+
+// Cloud Logging API v2 routes
+const v2 = new KoaRouter({ prefix: '/v2' })
+
+// Write log entries
+v2.post('/entries\\:write', Controllers.writeEntries)
+
+// List log entries (POST with filter in body)
+v2.post('/entries\\:list', Controllers.listEntries)
+
+// Debug endpoint
+v2.get('/debug', async (ctx) => {
+  ctx.body = {
+    message: 'Logging API debug endpoint',
+    routes: [
+      'POST /v2/entries:write',
+      'POST /v2/entries:list',
+      'GET /v2/projects/:project/logs',
+      'DELETE /v2/projects/:project/logs/:logId'
+    ]
+  }
+})
+
+// List all logs for a project
+v2.get('/projects/:project/logs', Controllers.listLogs)
+
+// Delete a log
+v2.delete('/projects/:project/logs/:logId', Controllers.deleteLog)
+
+Router.use(v2.routes())
+
+export { Router }

package/src/emulation/logging/Schemas.js

@@ -0,0 +1,82 @@
+import Joi from 'joi'
+
+// Cloud Logging severity levels
+const SEVERITY_LEVELS = [
+  'DEFAULT',
+  'DEBUG',
+  'INFO',
+  'NOTICE',
+  'WARNING',
+  'ERROR',
+  'CRITICAL',
+  'ALERT',
+  'EMERGENCY'
+]
+
+// MonitoredResource schema
+const MonitoredResourceSchema = Joi.object({
+  type: Joi.string().required(),
+  labels: Joi.object().pattern(Joi.string(), Joi.string()).optional()
+})
+
+// LogEntry schema
+const LogEntrySchema = Joi.object({
+  logName: Joi.string().pattern(/^projects\/[^/]+\/logs\/[^/]+$/).optional(),
+  resource: MonitoredResourceSchema.optional(),
+  timestamp: Joi.string().isoDate().optional(),
+  receiveTimestamp: Joi.string().isoDate().optional(),
+  severity: Joi.string().valid(...SEVERITY_LEVELS).optional(),
+  insertId: Joi.string().optional(),
+  httpRequest: Joi.object().optional(),
+  labels: Joi.object().pattern(Joi.string(), Joi.string()).optional(),
+  operation: Joi.object({
+    id: Joi.string().optional(),
+    producer: Joi.string().optional(),
+    first: Joi.boolean().optional(),
+    last: Joi.boolean().optional()
+  }).optional(),
+  trace: Joi.string().optional(),
+  spanId: Joi.string().optional(),
+  traceSampled: Joi.boolean().optional(),
+  sourceLocation: Joi.object({
+    file: Joi.string().optional(),
+    line: Joi.number().optional(),
+    function: Joi.string().optional()
+  }).optional(),
+  // One of the payload fields must be present
+  textPayload: Joi.string().optional(),
+  jsonPayload: Joi.object().optional(),
+  protoPayload: Joi.object().optional()
+}).or('textPayload', 'jsonPayload', 'protoPayload')
+
+// Write entries request schema
+export const WriteEntriesRequestSchema = Joi.object({
+  logName: Joi.string().pattern(/^projects\/[^/]+\/logs\/[^/]+$/).optional(),
+  resource: MonitoredResourceSchema.optional(),
+  labels: Joi.object().pattern(Joi.string(), Joi.string()).optional(),
+  entries: Joi.array().items(LogEntrySchema).min(1).required(),
+  partialSuccess: Joi.boolean().optional(),
+  dryRun: Joi.boolean().optional()
+})
+
+// List entries request schema
+export const ListEntriesRequestSchema = Joi.object({
+  resourceNames: Joi.array().items(Joi.string()).optional(),
+  filter: Joi.string().optional(),
+  orderBy: Joi.string().optional(),
+  pageSize: Joi.number().integer().min(1).max(1000).optional(),
+  pageToken: Joi.string().optional()
+})
+
+// Delete log request schema (path parameters)
+export const DeleteLogRequestSchema = Joi.object({
+  project: Joi.string().required(),
+  logId: Joi.string().required()
+})
+
+// List logs request schema
+export const ListLogsRequestSchema = Joi.object({
+  project: Joi.string().required(),
+  pageSize: Joi.number().integer().min(1).max(1000).optional(),
+  pageToken: Joi.string().optional()
+})

package/src/emulation/logging/Server.js

@@ -0,0 +1,108 @@
+import Koa from 'koa'
+import bodyParser from 'koa-bodyparser'
+import KoaRouter from 'koa-router'
+import { Application } from '../../configs/Application.js'
+import { Logger } from '../../singletons/Logger.js'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { ErrorCatcher } from '../../middleware/ErrorCatcher.js'
+import { Reply } from '../../middleware/Reply.js'
+import { TraceId } from '../../middleware/TraceId.js'
+import { Router as LoggingRouter } from './Router.js'
+
+const { environment, runId, ports } = Application
+const LOGGING_PORT = ports.logging || 8087
+
+// Register collections (no-op for SQLite - tables created at DB initialization)
+const registerCollections = () => {
+  Logger.log({
+    level: 'info',
+    message: 'Logging tables ready (SQLite)',
+    data: { tables: ['logging_entries', 'logging_logs'] }
+  })
+}
+
+const start = async () => {
+  try {
+    // Register collections (no-op for SQLite)
+    registerCollections()
+
+    // Create Koa app
+    const app = new Koa()
+
+    // Middleware
+    app.use(ErrorCatcher())
+    app.use(TraceId())
+    app.use(Reply())
+    app.use(bodyParser())
+
+    // Router
+    const router = new KoaRouter()
+    router.use(LoggingRouter.routes())
+
+    app.use(router.routes())
+    app.use(router.allowedMethods())
+
+    // Start server
+    const server = app.listen(LOGGING_PORT, () => {
+      Logger.log({
+        level: 'info',
+        message: 'Cloud Logging emulation server started',
+        data: {
+          environment,
+          runId,
+          port: LOGGING_PORT,
+          endpoints: [
+            'POST /v2/entries:write',
+            'POST /v2/entries:list',
+            'GET /v2/projects/{project}/logs',
+            'DELETE /v2/projects/{project}/logs/{logId}'
+          ]
+        }
+      })
+    })
+
+    return server
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to start Cloud Logging server',
+      data: { error: error.message, stack: error.stack }
+    })
+    process.exit(1)
+  }
+}
+
+const shutdown = async () => {
+  Logger.log({
+    level: 'info',
+    message: 'Shutting down Cloud Logging server'
+  })
+  SqliteStore.shutdown()
+  process.exit(0)
+}
+
+// Start server if this file is run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  start()
+
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+
+  process.on('unhandledRejection', error => {
+    Logger.log({
+      level: 'error',
+      message: 'Unhandled rejection detected',
+      data: { error: error.message, stack: error.stack }
+    })
+  })
+
+  process.on('uncaughtException', error => {
+    Logger.log({
+      level: 'error',
+      message: 'Uncaught exception detected',
+      data: { error: error.message, stack: error.stack }
+    })
+  })
+}
+
+export { start, shutdown }