@workglow/storage 0.0.114 → 0.0.116

package/dist/browser.js

@@ -1138,6 +1138,102 @@ function resolveRepositoryFromRegistry(id, format, registry) {
   return repo;
 }
 registerInputResolver("storage:tabular", resolveRepositoryFromRegistry);
+// src/util/traced.ts
+import { getTelemetryProvider, SpanStatusCode } from "@workglow/util";
+async function traced(spanName, storageName, fn) {
+  const telemetry = getTelemetryProvider();
+  if (!telemetry.isEnabled)
+    return fn();
+  const span = telemetry.startSpan(spanName, {
+    attributes: { "workglow.storage.name": storageName }
+  });
+  try {
+    const result = await fn();
+    span.setStatus(SpanStatusCode.OK);
+    return result;
+  } catch (err) {
+    span.setStatus(SpanStatusCode.ERROR, err instanceof Error ? err.message : String(err));
+    throw err;
+  } finally {
+    span.end();
+  }
+}
+
+// src/tabular/TelemetryTabularStorage.ts
+class TelemetryTabularStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  put(value) {
+    return traced("workglow.storage.tabular.put", this.storageName, () => this.inner.put(value));
+  }
+  putBulk(values) {
+    return traced("workglow.storage.tabular.putBulk", this.storageName, () => this.inner.putBulk(values));
+  }
+  get(key) {
+    return traced("workglow.storage.tabular.get", this.storageName, () => this.inner.get(key));
+  }
+  delete(key) {
+    return traced("workglow.storage.tabular.delete", this.storageName, () => this.inner.delete(key));
+  }
+  getAll(options) {
+    return traced("workglow.storage.tabular.getAll", this.storageName, () => this.inner.getAll(options));
+  }
+  deleteAll() {
+    return traced("workglow.storage.tabular.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  size() {
+    return traced("workglow.storage.tabular.size", this.storageName, () => this.inner.size());
+  }
+  deleteSearch(criteria) {
+    return traced("workglow.storage.tabular.deleteSearch", this.storageName, () => this.inner.deleteSearch(criteria));
+  }
+  getBulk(offset, limit) {
+    return traced("workglow.storage.tabular.getBulk", this.storageName, () => this.inner.getBulk(offset, limit));
+  }
+  query(criteria, options) {
+    return traced("workglow.storage.tabular.query", this.storageName, () => this.inner.query(criteria, options));
+  }
+  records(pageSize) {
+    return this.inner.records(pageSize);
+  }
+  pages(pageSize) {
+    return this.inner.pages(pageSize);
+  }
+  subscribeToChanges(callback, options) {
+    return this.inner.subscribeToChanges(callback, options);
+  }
+  setupDatabase() {
+    return this.inner.setupDatabase();
+  }
+  destroy() {
+    return this.inner.destroy();
+  }
+  [Symbol.dispose]() {
+    return this.inner[Symbol.dispose]();
+  }
+  [Symbol.asyncDispose]() {
+    return this.inner[Symbol.asyncDispose]();
+  }
+  on(name, fn) {
+    this.inner.on(name, fn);
+  }
+  off(name, fn) {
+    this.inner.off(name, fn);
+  }
+  emit(name, ...args) {
+    this.inner.emit(name, ...args);
+  }
+  once(name, fn) {
+    this.inner.once(name, fn);
+  }
+  waitOn(name) {
+    return this.inner.waitOn(name);
+  }
+}
 // src/kv/IKvStorage.ts
 var DefaultKeyValueSchema = {
   type: "object",
@@ -1269,6 +1365,54 @@ class InMemoryKvStorage extends KvViaTabularStorage {
     this.tabularRepository = new InMemoryTabularStorage(DefaultKeyValueSchema, DefaultKeyValueKey);
   }
 }
+// src/kv/TelemetryKvStorage.ts
+class TelemetryKvStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  put(key, value) {
+    return traced("workglow.storage.kv.put", this.storageName, () => this.inner.put(key, value));
+  }
+  putBulk(items) {
+    return traced("workglow.storage.kv.putBulk", this.storageName, () => this.inner.putBulk(items));
+  }
+  get(key) {
+    return traced("workglow.storage.kv.get", this.storageName, () => this.inner.get(key));
+  }
+  delete(key) {
+    return traced("workglow.storage.kv.delete", this.storageName, () => this.inner.delete(key));
+  }
+  getAll() {
+    return traced("workglow.storage.kv.getAll", this.storageName, () => this.inner.getAll());
+  }
+  deleteAll() {
+    return traced("workglow.storage.kv.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  size() {
+    return traced("workglow.storage.kv.size", this.storageName, () => this.inner.size());
+  }
+  getObjectAsIdString(object) {
+    return this.inner.getObjectAsIdString(object);
+  }
+  on(name, fn) {
+    this.inner.on(name, fn);
+  }
+  off(name, fn) {
+    this.inner.off(name, fn);
+  }
+  emit(name, ...args) {
+    this.inner.emit(name, ...args);
+  }
+  once(name, fn) {
+    this.inner.once(name, fn);
+  }
+  waitOn(name) {
+    return this.inner.waitOn(name);
+  }
+}
 // src/queue/InMemoryQueueStorage.ts
 import {
   createServiceToken as createServiceToken9,
@@ -1480,6 +1624,60 @@ class InMemoryQueueStorage {
     return this.events.subscribe("change", filteredCallback);
   }
 }
+// src/queue/TelemetryQueueStorage.ts
+class TelemetryQueueStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  add(job) {
+    return traced("workglow.storage.queue.add", this.storageName, () => this.inner.add(job));
+  }
+  get(id) {
+    return traced("workglow.storage.queue.get", this.storageName, () => this.inner.get(id));
+  }
+  next(workerId) {
+    return traced("workglow.storage.queue.next", this.storageName, () => this.inner.next(workerId));
+  }
+  peek(status, num) {
+    return traced("workglow.storage.queue.peek", this.storageName, () => this.inner.peek(status, num));
+  }
+  size(status) {
+    return traced("workglow.storage.queue.size", this.storageName, () => this.inner.size(status));
+  }
+  complete(job) {
+    return traced("workglow.storage.queue.complete", this.storageName, () => this.inner.complete(job));
+  }
+  deleteAll() {
+    return traced("workglow.storage.queue.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  outputForInput(input) {
+    return traced("workglow.storage.queue.outputForInput", this.storageName, () => this.inner.outputForInput(input));
+  }
+  abort(id) {
+    return traced("workglow.storage.queue.abort", this.storageName, () => this.inner.abort(id));
+  }
+  getByRunId(runId) {
+    return traced("workglow.storage.queue.getByRunId", this.storageName, () => this.inner.getByRunId(runId));
+  }
+  saveProgress(id, progress, message, details) {
+    return traced("workglow.storage.queue.saveProgress", this.storageName, () => this.inner.saveProgress(id, progress, message, details));
+  }
+  delete(id) {
+    return traced("workglow.storage.queue.delete", this.storageName, () => this.inner.delete(id));
+  }
+  deleteJobsByStatusAndAge(status, olderThanMs) {
+    return traced("workglow.storage.queue.deleteJobsByStatusAndAge", this.storageName, () => this.inner.deleteJobsByStatusAndAge(status, olderThanMs));
+  }
+  setupDatabase() {
+    return this.inner.setupDatabase();
+  }
+  subscribeToChanges(callback, options) {
+    return this.inner.subscribeToChanges(callback, options);
+  }
+}
 // src/queue-limiter/InMemoryRateLimiterStorage.ts
 import { createServiceToken as createServiceToken10, sleep as sleep2 } from "@workglow/util";
 var IN_MEMORY_RATE_LIMITER_STORAGE = createServiceToken10("ratelimiter.storage.inMemory");
@@ -1933,6 +2131,26 @@ class InMemoryVectorStorage extends InMemoryTabularStorage {
     return topResults;
   }
 }
+// src/vector/TelemetryVectorStorage.ts
+class TelemetryVectorStorage extends TelemetryTabularStorage {
+  vectorInner;
+  constructor(storageName, inner) {
+    super(storageName, inner);
+    this.vectorInner = inner;
+  }
+  getVectorDimensions() {
+    return this.vectorInner.getVectorDimensions();
+  }
+  similaritySearch(query, options) {
+    return traced("workglow.storage.vector.similaritySearch", this.storageName, () => this.vectorInner.similaritySearch(query, options));
+  }
+  hybridSearch(query, options) {
+    if (!this.vectorInner.hybridSearch) {
+      throw new Error("hybridSearch is not supported by the underlying storage implementation");
+    }
+    return traced("workglow.storage.vector.hybridSearch", this.storageName, () => this.vectorInner.hybridSearch(query, options));
+  }
+}
 // src/credentials/EncryptedKvCredentialStore.ts
 import { decrypt, encrypt } from "@workglow/util";
 
@@ -5203,6 +5421,7 @@ class IndexedDbVectorStorage extends IndexedDbTabularStorage {
   }
 }
 export {
+  traced,
   registerTabularRepository,
   isSearchCondition,
   getVectorProperty,
@@ -5211,6 +5430,10 @@ export {
   getGlobalTabularRepositories,
   ensureIndexedDbTable,
   dropIndexedDbTable,
+  TelemetryVectorStorage,
+  TelemetryTabularStorage,
+  TelemetryQueueStorage,
+  TelemetryKvStorage,
   TABULAR_REPOSITORY,
   TABULAR_REPOSITORIES,
   SupabaseTabularStorage,
@@ -5266,4 +5489,4 @@ export {
   BaseTabularStorage
 };
 
-//# debugId=E678A7B863107B3464756E2164756E21
+//# debugId=73D6D962906C686A64756E2164756E21