document-dataply 0.0.14-alpha.3 → 0.0.14-alpha.4

package/dist/cjs/index.js

@@ -14600,11 +14600,19 @@ var E = class {
 
 // src/core/AnalysisProvider.ts
 var AnalysisProvider = class {
-  constructor(api) {
+  constructor(api, loggerManager) {
     this.api = api;
+    this.loggerManager = loggerManager;
   }
   /** Overflow row PK assigned by AnalysisManager during initialization. */
   storageKey = -1;
+  _logger;
+  get logger() {
+    if (!this._logger) {
+      this._logger = this.loggerManager.create(`document-dataply:analysis:${this.name}`);
+    }
+    return this._logger;
+  }
 };
 
 // src/core/RealtimeAnalysisProvider.ts
@@ -14650,6 +14658,7 @@ var FTSTermCount = class extends IntervalAnalysisProvider {
   termCount = {};
   sampleSize = 0;
   async serialize(tx) {
+    this.logger.debug(`Starting serialize`);
     const docs = await this.sample({ count: this.api.analysisManager.sampleSize }, tx);
     this.termCount = {};
     this.sampleSize = docs.length;
@@ -14698,12 +14707,15 @@ var FTSTermCount = class extends IntervalAnalysisProvider {
       }
     }
     this.termCount = optimizedTermCount;
+    this.logger.debug(`Serialize complete, sampleSize: ${this.sampleSize}`);
     return JSON.stringify({ _sampleSize: this.sampleSize, ...this.termCount });
   }
   async load(data, tx) {
+    this.logger.debug(`Loading data`);
     this.termCount = {};
     this.sampleSize = 0;
     if (!data) {
+      this.logger.debug(`No existing data found, initialized as empty`);
       return;
     }
     try {
@@ -14713,7 +14725,9 @@ var FTSTermCount = class extends IntervalAnalysisProvider {
         this.sampleSize = typeof _sampleSize === "number" ? _sampleSize : 0;
         this.termCount = rest;
       }
+      this.logger.debug(`Successfully parsed existing data (sampleSize: ${this.sampleSize})`);
     } catch (e) {
+      this.logger.warn(`Failed to parse existing data`, e);
     }
   }
   /**
@@ -14757,18 +14771,22 @@ var BuiltinAnalysisProviders = [
 
 // src/core/AnalysisManager.ts
 var AnalysisManager = class {
-  constructor(api, schedule, sampleSize, logger) {
+  constructor(api, schedule, sampleSize, loggerManager) {
     this.api = api;
     this.sampleSize = sampleSize;
-    this.logger = logger;
+    this.loggerManager = loggerManager;
+    this.logger = loggerManager.create("document-dataply:analysis");
     this.cron = new E(schedule, async () => {
       if (this.flushing) return;
       await this.api.flushAnalysis();
+    }, {
+      paused: true
     });
   }
   providers = /* @__PURE__ */ new Map();
   cron = null;
   flushing = false;
+  logger;
   /**
    * Stop the background analysis cron job.
    */
@@ -14784,7 +14802,7 @@ var AnalysisManager = class {
    */
   registerBuiltinProviders() {
     for (const Provider of BuiltinAnalysisProviders) {
-      const instance = new Provider(this.api);
+      const instance = new Provider(this.api, this.loggerManager);
       this.registerProvider(instance);
     }
   }
@@ -15034,7 +15052,7 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
       this,
       options.analysisSchedule ?? "* */1 * * *",
       options.analysisSampleSize ?? 1e3,
-      this.loggerManager.create("document-dataply:analysis")
+      this.loggerManager
     );
     this.hook.onceAfter("close", async () => {
       this.logger.info("DocumentDataplyAPI closing");

package/dist/types/core/AnalysisManager.d.ts

@@ -1,15 +1,16 @@
 import type { AnalysisHeader, DocumentJSON, FlattenedDocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
 import type { AnalysisProvider } from './AnalysisProvider';
-import { Transaction, Logger } from 'dataply';
+import { Transaction, LoggerManager } from 'dataply';
 export declare class AnalysisManager<T extends DocumentJSON> {
     private api;
     readonly sampleSize: number;
-    private logger;
+    private loggerManager;
     private providers;
     private cron;
     private flushing;
-    constructor(api: DocumentDataplyAPI<T>, schedule: string, sampleSize: number, logger: Logger);
+    private logger;
+    constructor(api: DocumentDataplyAPI<T>, schedule: string, sampleSize: number, loggerManager: LoggerManager);
     /**
      * Stop the background analysis cron job.
      */

package/dist/types/core/AnalysisProvider.d.ts

@@ -1,15 +1,18 @@
 import type { DocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
-import type { Transaction } from 'dataply';
+import type { Transaction, Logger, LoggerManager } from 'dataply';
 /**
  * Abstract base class for analysis providers.
  * Subclasses should extend either RealtimeAnalysisProvider or IntervalAnalysisProvider.
  */
 export declare abstract class AnalysisProvider<T extends DocumentJSON = DocumentJSON> {
     protected api: DocumentDataplyAPI<T>;
+    protected loggerManager: LoggerManager;
     /** Overflow row PK assigned by AnalysisManager during initialization. */
     storageKey: number;
-    constructor(api: DocumentDataplyAPI<T>);
+    private _logger?;
+    protected get logger(): Logger;
+    constructor(api: DocumentDataplyAPI<T>, loggerManager: LoggerManager);
     /**
      * Unique name of this analysis type (e.g. 'ftsTermCount').
      * Used as the key in the AnalysisHeader.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.14-alpha.3",
+  "version": "0.0.14-alpha.4",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",