@smplkit/sdk 3.0.49 → 3.0.50

package/dist/index.cjs

@@ -17597,6 +17597,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;
 }
@@ -21774,6 +21777,72 @@ var FlagsClient = class {
 
 // src/logging/client.ts
 var import_openapi_fetch5 = __toESM(require("openapi-fetch"), 1);
+
+// 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();
@@ -21815,11 +21884,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;
@@ -22012,6 +22090,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 {
@@ -22044,13 +22123,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();
@@ -22142,41 +22217,107 @@ 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;
-        }
+  /**
+   * Refresh resolved levels and apply them to adapter-known loggers.
+   *
+   * Computes a resolved level (via {@link resolveLevel}) for every entry
+   * currently in `_loggersCache` *and* every adapter-known logger name —
+   * even loggers whose own `level` is `null`, because they may inherit
+   * via group chain or dot-notation ancestry.
+   *
+   * The full resolved-level snapshot is stored in `_resolvedLevelStore`
+   * so callers can diff pre-vs-post and fire change listeners on actual
+   * effective-level deltas (group-driven changes included). Adapter pushes
+   * only happen for adapter-known names where `managed !== false`.
+   * @internal
+   */
+  _applyLevels() {
+    const environment = this._parent?._environment ?? "";
+    const newResolved = {};
+    for (const id of Object.keys(this._loggersCache)) {
+      newResolved[id] = resolveLevel(id, environment, this._loggersCache, this._groupsCache);
+    }
+    for (const name of this._knownLoggerNames) {
+      if (!(name in newResolved)) {
+        newResolved[name] = resolveLevel(name, environment, this._loggersCache, this._groupsCache);
       }
-      debug("resolution", `${logger.id} -> ${effectiveLevel}`);
+    }
+    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() {
@@ -22210,33 +22351,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",
@@ -22248,50 +22370,25 @@ 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._emitDeletedEvent(id, "websocket");
+    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",
@@ -22303,11 +22400,68 @@ var LoggingClient = class {
     debug("websocket", `group_deleted event received: ${JSON.stringify(data)}`);
     const id = data.id;
     if (!id) return;
-    delete this._groupStore[id];
+    delete this._groupsCache[id];
+    const preResolved = { ...this._resolvedLevelStore };
+    this._applyLevels();
+    this._emitDeletedEvent(id, "websocket");
+    this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket", /* @__PURE__ */ new Set([id]));
+  };
+  /**
+   * @internal Fire change listeners for every logger whose resolved level
+   * changed between `pre` and `post`. Stores resolved levels, not raw
+   * `logger.level`, so a group-driven change actually fires. Keys that
+   * disappeared from `post` are emitted with `deleted: true`.
+   */
+  _fireDeltas(pre, post, source, excludeIds) {
+    const changed = [];
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(pre), ...Object.keys(post)]);
+    for (const k of allKeys) {
+      if (excludeIds?.has(k)) continue;
+      if (pre[k] !== post[k]) changed.push(k);
+    }
+    if (changed.length === 0) return;
+    const buildEvent = (id) => {
+      const isDeletion = id in pre && !(id in post);
+      const fields = {
+        id,
+        source,
+        level: post[id] ?? null
+      };
+      if (isDeletion) fields.deleted = true;
+      return new LoggerChangeEvent(fields);
+    };
+    const firstKey = changed[0];
+    const globalEvent = buildEvent(firstKey);
+    for (const cb of this._globalListeners) {
+      try {
+        cb(globalEvent);
+      } catch {
+      }
+    }
+    for (const k of changed) {
+      const keyCallbacks = this._keyListeners.get(k);
+      if (keyCallbacks) {
+        const event = buildEvent(k);
+        for (const cb of keyCallbacks) {
+          try {
+            cb(event);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * @internal Always emit a deleted event for `id` on global and per-key
+   * listeners. Used by `logger_deleted` / `group_deleted` handlers to
+   * preserve the explicit notification contract even when nothing in the
+   * resolved-level store changed (e.g. server removed an unknown logger).
+   */
+  _emitDeletedEvent(id, source) {
     const event = new LoggerChangeEvent({
       id,
       level: null,
-      source: "websocket",
+      source,
       deleted: true
     });
     for (const cb of this._globalListeners) {
@@ -22316,7 +22470,7 @@ var LoggingClient = class {
       } catch (err) {
         debug(
           "websocket",
-          `group_deleted listener error: ${err instanceof Error ? err.message : String(err)}`
+          `deleted listener error: ${err instanceof Error ? err.message : String(err)}`
         );
       }
     }
@@ -22328,22 +22482,22 @@ var LoggingClient = class {
         } catch (err) {
           debug(
             "websocket",
-            `group_deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
+            `deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
     }
-  };
+  }
   _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) {
@@ -22352,58 +22506,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