@spooky-sync/core 0.0.1-canary.8 → 0.0.1-canary.80

package/src/services/logger/index.ts

@@ -1,114 +1,19 @@
-import pino, { Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
-import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-proto';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { createContextKey } from '@opentelemetry/api';
-
-const CATEGORY_KEY = createContextKey('Category');
+import pino, { type Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
+import type { PinoTransmit } from '../../types';
 
 export type Logger = PinoLogger;
 
-// Map pino levels to OTEL severity numbers
-// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#severity-fields
-function mapLevelToSeverityNumber(level: string): number {
-  switch (level) {
-    case 'trace':
-      return 1;
-    case 'debug':
-      return 5;
-    case 'info':
-      return 9;
-    case 'warn':
-      return 13;
-    case 'error':
-      return 17;
-    case 'fatal':
-      return 21;
-    default:
-      return 9;
-  }
-}
-
-export function createLogger(level: Level = 'info', otelEndpoint?: string): Logger {
+export function createLogger(level: Level = 'info', transmit?: PinoTransmit): Logger {
   const browserConfig: LoggerOptions['browser'] = {
     asObject: true,
     write: (o: any) => {
+      // oxlint-disable-next-line no-console
       console.log(JSON.stringify(o));
     },
   };
 
-  if (otelEndpoint) {
-    // Initialize OTEL LoggerProvider
-    const resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: 'spooky-client',
-    });
-
-    const exporter = new OTLPLogExporter({
-      url: otelEndpoint,
-    });
-
-    // Pass processors in constructor as this SDK version requires it
-    const loggerProvider = new LoggerProvider({
-      resource,
-      processors: [new BatchLogRecordProcessor(exporter)],
-    });
-
-    const otelLogger: Record<string, ReturnType<typeof loggerProvider.getLogger>> = {};
-
-    const getOtelLogger = (category: string) => {
-      if (!otelLogger[category]) {
-        otelLogger[category] = loggerProvider.getLogger(category);
-      }
-      return otelLogger[category];
-    };
-
-    browserConfig.transmit = {
-      level: level,
-      send: (levelLabel: string, logEvent: any) => {
-        try {
-          const messages = [...logEvent.messages];
-          const severityNumber = mapLevelToSeverityNumber(levelLabel);
-
-          // Construct the message body
-          let body = '';
-          const msg = messages.pop();
-
-          if (typeof msg === 'string') {
-            body = msg;
-          } else if (msg) {
-            body = JSON.stringify(msg);
-          }
-
-          let category = 'spooky-client::unknown';
-
-          const attributes = {};
-          for (const msg of messages) {
-            if (typeof msg === 'object') {
-              if (msg.Category) {
-                category = msg.Category;
-                delete msg.Category;
-              }
-              Object.assign(attributes, msg);
-            }
-          }
-
-          // Emit to OTEL SDK
-          getOtelLogger(category).emit({
-            severityNumber: severityNumber,
-            severityText: levelLabel.toUpperCase(),
-            body: body,
-            attributes: {
-              ...logEvent.bindings[0],
-              ...attributes,
-            },
-            timestamp: new Date(logEvent.ts),
-          });
-        } catch (e) {
-          console.warn('Failed to transmit log to OTEL endpoint', e);
-        }
-      },
-    };
+  if (transmit) {
+    browserConfig.transmit = transmit;
   }
 
   return pino({

package/src/services/persistence/localstorage.ts

@@ -1,5 +1,5 @@
-import { Logger } from 'pino';
-import { PersistenceClient } from '../../types';
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
 
 export class LocalStoragePersistenceClient implements PersistenceClient {
   private logger: Logger;

package/src/services/persistence/resilient.ts

@@ -0,0 +1,41 @@
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
+
+export class ResilientPersistenceClient implements PersistenceClient {
+  private logger: Logger;
+
+  constructor(
+    private inner: PersistenceClient,
+    logger: Logger
+  ) {
+    this.logger = logger.child({ service: 'ResilientPersistenceClient' });
+  }
+
+  set<T>(key: string, value: T): Promise<void> {
+    return this.inner.set(key, value);
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    try {
+      return await this.inner.get<T>(key);
+    } catch (e) {
+      this.logger.warn(
+        { key, error: e, Category: 'sp00ky-client::ResilientPersistenceClient::get' },
+        'Persistence read failed, dropping key'
+      );
+      // Best-effort cleanup of the corrupt key; if removal also fails, the key
+      // just gets dropped again on the next failed read, so the failure is safe.
+      await this.inner.remove(key).catch((removeErr) => {
+        this.logger.debug(
+          { key, error: removeErr, Category: 'sp00ky-client::ResilientPersistenceClient::get' },
+          'Failed to drop corrupt persistence key'
+        );
+      });
+      return null;
+    }
+  }
+
+  remove(key: string): Promise<void> {
+    return this.inner.remove(key);
+  }
+}

package/src/services/persistence/surrealdb.ts

@@ -1,7 +1,7 @@
-import { PersistenceClient } from '../../types';
+import type { PersistenceClient } from '../../types';
 import { parseRecordIdString, surql } from '../../utils/index';
-import { Logger } from 'pino';
-import { AbstractDatabaseService } from '../database/database';
+import type { Logger } from 'pino';
+import type { AbstractDatabaseService } from '../database/database';
 
 export class SurrealDBPersistenceClient implements PersistenceClient {
   private logger: Logger;
@@ -15,11 +15,11 @@ export class SurrealDBPersistenceClient implements PersistenceClient {
 
   async set<T>(key: string, val: T) {
     try {
-      const id = parseRecordIdString(`_spooky_kv:${key}`);
+      const id = parseRecordIdString(`_00_kv:${key}`);
       await this.db.query(surql.seal(surql.upsert('id', 'data')), { id, data: { val } });
     } catch (error) {
       this.logger.error(
-        { error, Category: 'spooky-client::SurrealDBPersistenceClient::set' },
+        { error, Category: 'sp00ky-client::SurrealDBPersistenceClient::set' },
         'Failed to set KV'
       );
       throw error;
@@ -28,7 +28,7 @@ export class SurrealDBPersistenceClient implements PersistenceClient {
 
   async get<T>(key: string) {
     try {
-      const id = parseRecordIdString(`_spooky_kv:${key}`);
+      const id = parseRecordIdString(`_00_kv:${key}`);
       const [result] = await this.db.query<[{ val: T }]>(
         surql.seal(surql.selectById('id', ['val'])),
         {
@@ -41,7 +41,7 @@ export class SurrealDBPersistenceClient implements PersistenceClient {
       return result.val;
     } catch (error) {
       this.logger.warn(
-        { error, Category: 'spooky-client::SurrealDBPersistenceClient::get' },
+        { error, Category: 'sp00ky-client::SurrealDBPersistenceClient::get' },
         'Failed to get KV'
       );
       return null;
@@ -50,11 +50,11 @@ export class SurrealDBPersistenceClient implements PersistenceClient {
 
   async remove(key: string) {
     try {
-      const id = parseRecordIdString(`_spooky_kv:${key}`);
+      const id = parseRecordIdString(`_00_kv:${key}`);
       await this.db.query(surql.seal(surql.delete('id')), { id });
     } catch (err) {
       this.logger.info(
-        { err, Category: 'spooky-client::SurrealDBPersistenceClient::remove' },
+        { err, Category: 'sp00ky-client::SurrealDBPersistenceClient::remove' },
         'Failed to delete KV'
       );
     }