@smplkit/sdk 3.0.49 → 3.0.51

package/dist/index.js

@@ -17527,6 +17527,9 @@ function _parseDebugEnv(value) {
   return v === "1" || v === "true" || v === "yes";
 }
 var _DEBUG_ENABLED = _parseDebugEnv(process.env.SMPLKIT_DEBUG ?? "");
+function isDebugEnabled() {
+  return _DEBUG_ENABLED;
+}
 function enableDebug() {
   _DEBUG_ENABLED = true;
 }
@@ -19218,12 +19221,10 @@ var LoggerChangeEvent = class {
   id;
   source;
   level;
-  deleted;
   constructor(fields) {
     this.id = fields.id;
     this.source = fields.source;
-    if (fields.level !== void 0) this.level = fields.level;
-    if (fields.deleted) this.deleted = fields.deleted;
+    this.level = fields.level;
     Object.freeze(this);
   }
 };
@@ -21704,6 +21705,72 @@ var FlagsClient = class {
 
 // src/logging/client.ts
 import createClient5 from "openapi-fetch";
+
+// src/logging/_resolution.ts
+var FALLBACK_LEVEL = "INFO";
+function resolveLevel(loggerId, environment, loggers, groups) {
+  const direct = _resolveForEntry(loggerId, environment, loggers, groups);
+  if (direct !== null) {
+    if (isDebugEnabled()) {
+      const source = _findResolutionSource(loggerId, environment, loggers, groups);
+      debug("resolution", `${loggerId} -> ${direct} (source: ${source})`);
+    }
+    return direct;
+  }
+  const parts = loggerId.split(".");
+  for (let i = parts.length - 1; i > 0; i--) {
+    const ancestorId = parts.slice(0, i).join(".");
+    const result = _resolveForEntry(ancestorId, environment, loggers, groups);
+    if (result !== null) {
+      debug("resolution", `${loggerId} -> ${result} (source: ancestor "${ancestorId}")`);
+      return result;
+    }
+  }
+  debug("resolution", `${loggerId} -> ${FALLBACK_LEVEL} (source: system default)`);
+  return FALLBACK_LEVEL;
+}
+function _resolveForEntry(loggerId, environment, loggers, groups) {
+  const entry = loggers[loggerId];
+  if (entry === void 0) return null;
+  const envLevel = _envLevel(entry.environments, environment);
+  if (envLevel !== null) return envLevel;
+  if (entry.level !== null && entry.level !== void 0) return entry.level;
+  return _resolveGroupChain(entry.group, environment, groups);
+}
+function _findResolutionSource(loggerId, environment, loggers, groups) {
+  const entry = loggers[loggerId];
+  if (entry === void 0) return "not found";
+  const envLevel = _envLevel(entry.environments, environment);
+  if (envLevel !== null) return `env override "${environment}"`;
+  if (entry.level !== null && entry.level !== void 0) return "base level";
+  const groupResult = _resolveGroupChain(entry.group, environment, groups);
+  if (groupResult !== null) return `group "${entry.group}"`;
+  return "unknown";
+}
+function _resolveGroupChain(groupId, environment, groups) {
+  const visited = /* @__PURE__ */ new Set();
+  let currentId = groupId;
+  while (currentId !== null && currentId !== void 0 && !visited.has(currentId)) {
+    visited.add(currentId);
+    const group = groups[currentId];
+    if (group === void 0) break;
+    const envLevel = _envLevel(group.environments, environment);
+    if (envLevel !== null) return envLevel;
+    if (group.level !== null && group.level !== void 0) return group.level;
+    currentId = group.group;
+  }
+  return null;
+}
+function _envLevel(envs, environment) {
+  if (!envs || typeof envs !== "object") return null;
+  const envData = envs[environment];
+  if (!envData || typeof envData !== "object") return null;
+  const level = envData.level;
+  if (level === null || level === void 0) return null;
+  return level;
+}
+
+// src/logging/client.ts
 var LOGGING_BASE_URL = "https://logging.smplkit.com";
 var LoggerRegistrationBuffer2 = class {
   _seen = /* @__PURE__ */ new Set();
@@ -21745,11 +21812,20 @@ var LoggingClient = class {
   _explicitAdapters = false;
   _loggerBuffer = new LoggerRegistrationBuffer2();
   _loggerFlushTimer = null;
-  // Local stores for diff-based listener firing
-  _loggerStore = {};
-  // key -> level
-  _groupStore = {};
-  // key -> level
+  // Caches consulted by the resolution algorithm. The runtime client mutates
+  // these from install(), refresh(), and the WebSocket handlers; resolveLevel
+  // reads them on every apply.
+  _loggersCache = {};
+  _groupsCache = {};
+  // Resolved-level snapshot, used to decide whether to fire change listeners.
+  // Keyed by logger id; storing the *resolved* level (not raw `logger.level`)
+  // means a group-driven level shift fires listeners even when the logger's
+  // own level is untouched.
+  _resolvedLevelStore = {};
+  // Adapter-known logger names. The adapter knows loggers by their original
+  // name (e.g. `com.acme.payments`); the cache is keyed by the same string
+  // since the TypeScript SDK does not normalize.
+  _knownLoggerNames = /* @__PURE__ */ new Set();
   /** @internal */
   constructor(apiKey, ensureWs, timeout, baseUrl, extraHeaders) {
     this._apiKey = apiKey;
@@ -21942,6 +22018,7 @@ var LoggingClient = class {
         const loggers = adapter.discover();
         for (const { name, level } of loggers) {
           this._loggerBuffer.add(name, level, level, service, environment);
+          this._knownLoggerNames.add(name);
           discoveredCount++;
         }
       } catch {
@@ -21974,13 +22051,9 @@ var LoggingClient = class {
         "api",
         `fetched ${serverLoggers.length} logger(s) and ${serverGroups.length} group(s) from server`
       );
-      this._applyLevels(serverLoggers);
-      for (const l of serverLoggers) {
-        this._loggerStore[l.id] = l.level;
-      }
-      for (const g of serverGroups) {
-        this._groupStore[g.id] = g.level;
-      }
+      this._loggersCache = this._buildLoggersCache(serverLoggers);
+      this._groupsCache = this._buildGroupsCache(serverGroups);
+      this._applyLevels();
     } catch {
     }
     this._wsManager = this._ensureWs();
@@ -22072,41 +22145,104 @@ var LoggingClient = class {
     }
     return adapters;
   }
-  /** Apply resolved levels from server loggers to all adapters. */
-  _applyLevels(serverLoggers) {
-    for (const logger of serverLoggers) {
-      if (!logger.level) continue;
-      const env = this._parent?._environment;
-      let effectiveLevel = logger.level;
-      if (env && logger.environments) {
-        const envOverride = logger.environments[env];
-        if (envOverride?.level) {
-          effectiveLevel = envOverride.level;
-        }
-      }
-      debug("resolution", `${logger.id} -> ${effectiveLevel}`);
+  /**
+   * Refresh resolved levels and apply them to adapter-known loggers.
+   *
+   * Walks every adapter-known logger name through {@link resolveLevel}
+   * (env override → base → group chain → dot-notation ancestry → fallback)
+   * and pushes the result to every registered adapter. Loggers whose own
+   * `level` is `null` are still applied — that's the whole point of group
+   * inheritance and dot-notation ancestry.
+   *
+   * The resolved-level snapshot lives in `_resolvedLevelStore` so callers
+   * can diff pre-vs-post and fire change listeners on actual effective-
+   * level deltas. The store is scoped to adapter-known names: listener
+   * fanout pairs 1:1 with `adapter.applyLevel` calls, so a logger that
+   * the adapter doesn't know about has no apply and no listener fire.
+   * @internal
+   */
+  _applyLevels() {
+    const environment = this._parent?._environment ?? "";
+    const newResolved = {};
+    for (const name of this._knownLoggerNames) {
+      newResolved[name] = resolveLevel(name, environment, this._loggersCache, this._groupsCache);
+    }
+    this._resolvedLevelStore = newResolved;
+    for (const name of this._knownLoggerNames) {
+      const resolved = newResolved[name];
       const metrics = this._parent?._metrics;
       if (metrics) {
-        metrics.record("logging.level_changes", 1, "changes", { logger: logger.id });
+        metrics.record("logging.level_changes", 1, "changes", { logger: name });
       }
       for (const adapter of this._adapters) {
         try {
-          debug("adapter", `setLevel(${logger.id}, ${effectiveLevel})`);
-          adapter.applyLevel(logger.id, effectiveLevel);
+          debug("adapter", `setLevel(${name}, ${resolved})`);
+          adapter.applyLevel(name, resolved);
         } catch {
         }
       }
     }
   }
+  /** @internal Convert a server Logger list into the resolution cache. */
+  _buildLoggersCache(loggers) {
+    const out = {};
+    for (const l of loggers) {
+      if (l.id === null) continue;
+      out[l.id] = this._loggerToCacheEntry(l);
+    }
+    return out;
+  }
+  /** @internal Convert a server LogGroup list into the resolution cache. */
+  _buildGroupsCache(groups) {
+    const out = {};
+    for (const g of groups) {
+      if (g.id === null) continue;
+      out[g.id] = this._groupToCacheEntry(g);
+    }
+    return out;
+  }
+  /** @internal */
+  _loggerToCacheEntry(l) {
+    return {
+      level: l.level ?? null,
+      group: l.group ?? null,
+      managed: l.managed ?? null,
+      environments: l.environments ?? null
+    };
+  }
+  /** @internal */
+  _groupToCacheEntry(g) {
+    return {
+      level: g.level ?? null,
+      group: g.group ?? null,
+      environments: g.environments ?? null
+    };
+  }
   /** Called by adapter hooks when a new logger is created in the framework. */
   _onAdapterNewLogger(name, level) {
     debug("discovery", `new logger intercepted at runtime: ${name}`);
     const service = this._parent?._service ?? null;
     const environment = this._parent?._environment ?? null;
     this._loggerBuffer.add(name, level, level, service, environment);
+    this._knownLoggerNames.add(name);
     if (this._loggerBuffer.pendingCount >= 50) {
       void this._flushLoggerBuffer();
     }
+    if (this._started) {
+      const resolved = resolveLevel(
+        name,
+        this._parent?._environment ?? "",
+        this._loggersCache,
+        this._groupsCache
+      );
+      this._resolvedLevelStore[name] = resolved;
+      for (const adapter of this._adapters) {
+        try {
+          adapter.applyLevel(name, resolved);
+        } catch {
+        }
+      }
+    }
   }
   /** Flush buffered loggers to the bulk-register endpoint. */
   async _flushLoggerBuffer() {
@@ -22140,33 +22276,14 @@ var LoggingClient = class {
     const id = data.id;
     if (!id) return;
     void this._fetchSingleLogger(id).then((logger) => {
-      const oldLevel = this._loggerStore[id] ?? null;
-      const newLevel = logger?.level ?? null;
-      if (oldLevel === newLevel) return;
-      this._loggerStore[id] = newLevel;
-      if (logger) {
-        this._applyLevels([logger]);
-      }
-      const event = new LoggerChangeEvent({
-        id,
-        level: newLevel,
-        source: "websocket"
-      });
-      for (const cb of this._globalListeners) {
-        try {
-          cb(event);
-        } catch {
-        }
-      }
-      const idCallbacks = this._keyListeners.get(id);
-      if (idCallbacks) {
-        for (const cb of idCallbacks) {
-          try {
-            cb(event);
-          } catch {
-          }
-        }
+      const preResolved = { ...this._resolvedLevelStore };
+      if (logger !== null) {
+        this._loggersCache[id] = this._loggerToCacheEntry(logger);
+      } else {
+        delete this._loggersCache[id];
       }
+      this._applyLevels();
+      this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket");
     }).catch((err) => {
       debug(
         "websocket",
@@ -22178,50 +22295,24 @@ var LoggingClient = class {
     debug("websocket", `logger_deleted event received: ${JSON.stringify(data)}`);
     const id = data.id;
     if (!id) return;
-    delete this._loggerStore[id];
-    const event = new LoggerChangeEvent({
-      id,
-      level: null,
-      source: "websocket",
-      deleted: true
-    });
-    for (const cb of this._globalListeners) {
-      try {
-        cb(event);
-      } catch (err) {
-        debug(
-          "websocket",
-          `logger_deleted listener error: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    const idCallbacks = this._keyListeners.get(id);
-    if (idCallbacks) {
-      for (const cb of idCallbacks) {
-        try {
-          cb(event);
-        } catch (err) {
-          debug(
-            "websocket",
-            `logger_deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-    }
+    delete this._loggersCache[id];
+    const preResolved = { ...this._resolvedLevelStore };
+    this._applyLevels();
+    this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket", /* @__PURE__ */ new Set([id]));
   };
   _handleGroupChanged = (data) => {
     debug("websocket", `group_changed event received: ${JSON.stringify(data)}`);
     const id = data.id;
     if (!id) return;
     void this._fetchSingleGroup(id).then((group) => {
-      const oldLevel = this._groupStore[id] ?? null;
-      const newLevel = group?.level ?? null;
-      if (oldLevel === newLevel) return;
-      this._groupStore[id] = newLevel;
-      void this._listLoggers().then((loggers) => {
-        this._applyLevels(loggers);
-      }).catch(() => {
-      });
+      const preResolved = { ...this._resolvedLevelStore };
+      if (group !== null) {
+        this._groupsCache[id] = this._groupToCacheEntry(group);
+      } else {
+        delete this._groupsCache[id];
+      }
+      this._applyLevels();
+      this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket");
     }).catch((err) => {
       debug(
         "websocket",
@@ -22233,47 +22324,63 @@ var LoggingClient = class {
     debug("websocket", `group_deleted event received: ${JSON.stringify(data)}`);
     const id = data.id;
     if (!id) return;
-    delete this._groupStore[id];
-    const event = new LoggerChangeEvent({
-      id,
-      level: null,
-      source: "websocket",
-      deleted: true
-    });
-    for (const cb of this._globalListeners) {
-      try {
-        cb(event);
-      } catch (err) {
-        debug(
-          "websocket",
-          `group_deleted listener error: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    const idCallbacks = this._keyListeners.get(id);
-    if (idCallbacks) {
-      for (const cb of idCallbacks) {
+    delete this._groupsCache[id];
+    const preResolved = { ...this._resolvedLevelStore };
+    this._applyLevels();
+    this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket", /* @__PURE__ */ new Set([id]));
+  };
+  /**
+   * @internal Fire change listeners for every logger whose effective level
+   * changed between `pre` and `post`.
+   *
+   * Contract:
+   *   - Iterates loggers present in `post` (the post-apply resolved store).
+   *     A key in `pre` but not in `post` is a cache eviction — that key
+   *     itself fires nothing. Dependents that re-resolved to a new value
+   *     are still in `post` and fire normally.
+   *   - For every changed logger, fires every global listener once with
+   *     that logger's own payload (no "summary" event), then fires every
+   *     key-scoped listener registered for that id.
+   *   - One adapter.applyLevel call ↔ one listener notification per
+   *     subscriber. A trigger that moves N loggers fires the global
+   *     listener N times, not once.
+   *   - `suppressIds` is the deletion-event escape hatch: a deleted id
+   *     fires nothing for itself even when its adapter-known resolved
+   *     level moved (e.g. fell back to INFO).
+   */
+  _fireDeltas(pre, post, source, suppressIds) {
+    for (const id of Object.keys(post)) {
+      if (suppressIds?.has(id)) continue;
+      const next = post[id];
+      if (pre[id] === next) continue;
+      const event = new LoggerChangeEvent({ id, source, level: next });
+      for (const cb of this._globalListeners) {
         try {
           cb(event);
-        } catch (err) {
-          debug(
-            "websocket",
-            `group_deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
-          );
+        } catch {
+        }
+      }
+      const keyCallbacks = this._keyListeners.get(id);
+      if (keyCallbacks) {
+        for (const cb of keyCallbacks) {
+          try {
+            cb(event);
+          } catch {
+          }
         }
       }
     }
-  };
+  }
   _handleLoggersChanged = (_data) => {
     debug("websocket", `loggers_changed event received`);
     void this._resolveAndFire("websocket").catch(() => {
     });
   };
   /**
-   * Full refetch of loggers + log_groups, apply resolved levels to
-   * adapters, diff against local stores and fire change listeners
-   * (global once, per-key for each changed id). Shared between the
-   * `loggers_changed` WS handler and the public `refresh()` method.
+   * Full refetch of loggers + log_groups, rebuild the caches, re-resolve
+   * every adapter-known logger, and fire change listeners on resolved-level
+   * deltas. Shared between the `loggers_changed` WS handler and the
+   * public `refresh()` method.
    * @internal
    */
   async _resolveAndFire(source) {
@@ -22282,58 +22389,12 @@ var LoggingClient = class {
       this._listLogGroups()
     ]);
     debug("resolution", `resolution pass (trigger: ${source})`);
-    const changedLoggerIds = /* @__PURE__ */ new Set();
-    const newLoggerKeys = new Set(serverLoggers.map((l) => l.id));
-    for (const logger of serverLoggers) {
-      const key = logger.id;
-      const oldLevel = this._loggerStore[key] ?? null;
-      const newLevel = logger.level ?? null;
-      if (oldLevel !== newLevel || !(key in this._loggerStore)) {
-        changedLoggerIds.add(key);
-        this._loggerStore[key] = newLevel;
-      }
-    }
-    for (const key of Object.keys(this._loggerStore)) {
-      if (!newLoggerKeys.has(key)) {
-        changedLoggerIds.add(key);
-        delete this._loggerStore[key];
-      }
-    }
-    for (const group of serverGroups) {
-      this._groupStore[group.id] = group.level ?? null;
-    }
-    this._applyLevels(serverLoggers);
-    if (changedLoggerIds.size === 0) return;
-    const [firstKey] = changedLoggerIds;
-    const firstLogger = serverLoggers.find((l) => l.id === firstKey);
-    const globalEvent = new LoggerChangeEvent({
-      id: firstKey,
-      level: firstLogger?.level ?? null,
-      source
-    });
-    for (const cb of this._globalListeners) {
-      try {
-        cb(globalEvent);
-      } catch {
-      }
-    }
-    for (const key of changedLoggerIds) {
-      const keyCallbacks = this._keyListeners.get(key);
-      if (keyCallbacks) {
-        const l = serverLoggers.find((x) => x.id === key);
-        const keyEvent = new LoggerChangeEvent({
-          id: key,
-          level: l?.level ?? null,
-          source
-        });
-        for (const cb of keyCallbacks) {
-          try {
-            cb(keyEvent);
-          } catch {
-          }
-        }
-      }
-    }
+    const preResolved = { ...this._resolvedLevelStore };
+    this._loggersCache = this._buildLoggersCache(serverLoggers);
+    this._groupsCache = this._buildGroupsCache(serverGroups);
+    this._resolvedLevelStore = {};
+    this._applyLevels();
+    this._fireDeltas(preResolved, this._resolvedLevelStore, source);
   }
   // ------------------------------------------------------------------
   // Internal: single-resource fetchers