@decaf-ts/for-fabric 0.5.1-query → 0.5.1-query.3

package/lib/contracts/logging.cjs

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractLogger = void 0;
 const logging_1 = require("@decaf-ts/logging");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
+const logging_context_1 = require("./../contract/logging-context.cjs");
+(0, logging_context_1.ensureContractLogFieldRegistration)();
 /**
  * @description Logger implementation for Fabric chaincode contracts
  * @summary Adapts the standard logging interface to work with Fabric's chaincode context
@@ -35,13 +37,22 @@ const db_decorators_1 = require("@decaf-ts/db-decorators");
  */
 class ContractLogger extends logging_1.MiniLogger {
     constructor(context, conf, ctx) {
-        super(context, conf);
+        const normalizedConfig = (0, logging_context_1.enrichContractLoggingConfig)(conf, ctx);
+        super(context, normalizedConfig);
         if (!ctx) {
-            this.logger = new logging_1.MiniLogger(context, conf);
+            this.sink = {
+                info: (msg) => console.log(msg),
+                verbose: (msg) => console.log(msg),
+                debug: (msg) => console.debug(msg),
+                error: (msg) => console.error(msg),
+                trace: (msg) => console.trace(msg),
+                warn: (msg) => console.warn(msg),
+                silly: (msg) => console.debug(msg),
+            };
         }
         else {
-            this.logger = ctx.logging.getLogger(context);
-            ctx.logging.setLevel(conf?.level || logging_1.Logging.getConfig().level);
+            this.sink = ctx.logging.getLogger(context);
+            ctx.logging.setLevel(normalizedConfig?.level || logging_1.Logging.getConfig().level);
         }
     }
     /**
@@ -52,40 +63,40 @@ class ContractLogger extends logging_1.MiniLogger {
      * @param {Error} [stack] - Optional stack trace for errors
      * @return {void}
      */
-    log(level, msg, stack) {
+    log(level, msg, error, meta) {
         if (logging_1.NumericLogLevels[this.config("level")] <
             logging_1.NumericLogLevels[level])
             return;
         let method;
         switch (level) {
             case logging_1.LogLevel.benchmark:
-                method = this.logger.verbose;
+                method = this.sink.verbose;
                 break;
             case logging_1.LogLevel.info:
-                method = this.logger.info;
+                method = this.sink.info;
                 break;
             case logging_1.LogLevel.verbose:
-                method = this.logger.verbose;
+                method = this.sink.verbose;
                 break;
             case logging_1.LogLevel.debug:
-                method = this.logger.debug;
+                method = this.sink.debug;
                 break;
             case logging_1.LogLevel.error:
-                method = this.logger.error;
+                method = this.sink.error;
                 break;
             case logging_1.LogLevel.trace:
-                method = this.logger.trace;
+                method = this.sink.trace;
                 break;
             case logging_1.LogLevel.warn:
-                method = this.logger.warn;
+                method = this.sink.warn;
                 break;
             case logging_1.LogLevel.silly:
-                method = this.logger.silly;
+                method = this.sink.silly;
                 break;
             default:
                 throw new db_decorators_1.InternalError("Invalid log level");
         }
-        method.call(this.logger, this.createLog(level, msg, stack));
+        method.call(this.sink, this.createLog(level, msg, error, meta));
     }
 }
 exports.ContractLogger = ContractLogger;
@@ -104,4 +115,4 @@ const factory = (object, config, ctx) => {
 };
 // Set the factory as the default logger factory
 logging_1.Logging.setFactory(factory);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging.js","sourceRoot":"","sources":["../../src/contracts/logging.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  LoggerFactory,\n  Logging,\n  LogLevel,\n  LogMeta,\n  MiniLogger,\n  NumericLogLevels,\n  StringLike,\n} from \"@decaf-ts/logging\";\nimport { LoggingConfig } from \"@decaf-ts/logging\";\nimport { Context as Ctx } from \"fabric-contract-api\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport {\n  enrichContractLoggingConfig,\n  ensureContractLogFieldRegistration,\n} from \"../contract/logging-context\";\n\nensureContractLogFieldRegistration();\n\n/**\n * @description Logger implementation for Fabric chaincode contracts\n * @summary Adapts the standard logging interface to work with Fabric's chaincode context\n *\n * @param {string} context - The logging context name\n * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration\n * @param {Ctx} ctx - The Fabric chaincode context\n *\n * @class ContractLogger\n * @extends {MiniLogger}\n * @example\n * ```typescript\n * // In a Fabric chaincode contract\n * import { ContractLogger } from '@decaf-ts/for-fabric';\n *\n * export class MyContract extends Contract {\n *   @Transaction()\n *   async myFunction(ctx: Context): Promise<void> {\n *     const logger = new ContractLogger('MyContract', { level: 'info' }, ctx);\n *\n *     logger.info('Processing transaction');\n *     logger.debug('Transaction details:', { ... });\n *\n *     // Do something\n *\n *     logger.info('Transaction complete');\n *   }\n * }\n * ```\n */\nexport class ContractLogger extends MiniLogger {\n  protected sink!: {\n    verbose: (msg: string) => void;\n    info: (msg: string) => void;\n    debug: (msg: string) => void;\n    error: (msg: string) => void;\n    trace: (msg: string) => void;\n    warn: (msg: string) => void;\n    silly: (msg: string) => void;\n  };\n\n  constructor(\n    context: string,\n    conf: Partial<LoggingConfig> | undefined,\n    ctx?: Ctx\n  ) {\n    const normalizedConfig = enrichContractLoggingConfig(conf, ctx);\n    super(context, normalizedConfig);\n\n    if (!ctx) {\n      this.sink = {\n        info: (msg: string) => console.log(msg),\n        verbose: (msg: string) => console.log(msg),\n        debug: (msg: string) => console.debug(msg),\n        error: (msg: string) => console.error(msg),\n        trace: (msg: string) => console.trace(msg),\n        warn: (msg: string) => console.warn(msg),\n        silly: (msg: string) => console.debug(msg),\n      };\n    } else {\n      this.sink = ctx.logging.getLogger(context) as unknown as typeof this.sink;\n      ctx.logging.setLevel(\n        normalizedConfig?.level || Logging.getConfig().level\n      );\n    }\n  }\n\n  /**\n   * @description Logs a message at the specified level\n   * @summary Overrides the base log method to use the Fabric context's logger\n   * @param {LogLevel} level - The log level\n   * @param {StringLike | Error} msg - The message to log\n   * @param {Error} [stack] - Optional stack trace for errors\n   * @return {void}\n   */\n  protected override log(\n    level: LogLevel,\n    msg: StringLike | Error,\n    error?: Error,\n    meta?: LogMeta\n  ) {\n    if (\n      NumericLogLevels[this.config(\"level\") as LogLevel] <\n      NumericLogLevels[level]\n    )\n      return;\n\n    let method;\n    switch (level) {\n      case LogLevel.benchmark:\n        method = this.sink.verbose;\n        break;\n      case LogLevel.info:\n        method = this.sink.info;\n        break;\n      case LogLevel.verbose:\n        method = this.sink.verbose;\n        break;\n      case LogLevel.debug:\n        method = this.sink.debug;\n        break;\n      case LogLevel.error:\n        method = this.sink.error;\n        break;\n      case LogLevel.trace:\n        method = this.sink.trace;\n        break;\n      case LogLevel.warn:\n        method = this.sink.warn;\n        break;\n      case LogLevel.silly:\n        method = this.sink.silly;\n        break;\n      default:\n        throw new InternalError(\"Invalid log level\");\n    }\n    method.call(this.sink, this.createLog(level, msg, error, meta));\n  }\n}\n\n/**\n * @description Factory function for creating ContractLogger instances\n * @summary Creates a new ContractLogger with the given context, config, and Fabric context\n * @param {string} object - The logging context name\n * @param {Partial<LoggingConfig> | undefined} config - Optional logging configuration\n * @param {Ctx} ctx - The Fabric chaincode context\n * @return {ContractLogger} A new ContractLogger instance\n * @function factory\n * @memberOf module:fabric.contracts\n */\nconst factory: LoggerFactory = (\n  object?: string,\n  config?: Partial<LoggingConfig>,\n  ctx?: Ctx\n) => {\n  return new ContractLogger(\n    object || ContractLogger.name,\n    config || {},\n    ctx as Ctx\n  );\n};\n\n// Set the factory as the default logger factory\nLogging.setFactory(factory);\n"]}

package/lib/contracts/logging.d.ts

@@ -1,4 +1,4 @@
-import { Logger, LogLevel, MiniLogger, StringLike } from "@decaf-ts/logging";
+import { LogLevel, LogMeta, MiniLogger, StringLike } from "@decaf-ts/logging";
 import { LoggingConfig } from "@decaf-ts/logging";
 import { Context as Ctx } from "fabric-contract-api";
 /**
@@ -32,10 +32,15 @@ import { Context as Ctx } from "fabric-contract-api";
  * ```
  */
 export declare class ContractLogger extends MiniLogger {
-    /**
-     * @description The underlying Fabric logger instance
-     */
-    protected logger: Logger;
+    protected sink: {
+        verbose: (msg: string) => void;
+        info: (msg: string) => void;
+        debug: (msg: string) => void;
+        error: (msg: string) => void;
+        trace: (msg: string) => void;
+        warn: (msg: string) => void;
+        silly: (msg: string) => void;
+    };
     constructor(context: string, conf: Partial<LoggingConfig> | undefined, ctx?: Ctx);
     /**
      * @description Logs a message at the specified level
@@ -45,5 +50,5 @@ export declare class ContractLogger extends MiniLogger {
      * @param {Error} [stack] - Optional stack trace for errors
      * @return {void}
      */
-    protected log(level: LogLevel, msg: StringLike | Error, stack?: Error): void;
+    protected log(level: LogLevel, msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
 }

package/lib/esm/contract/logging-context.d.ts

@@ -0,0 +1,8 @@
+import { LoggingConfig } from "@decaf-ts/logging";
+import { Context as Ctx } from "fabric-contract-api";
+export declare function ensureContractLogFieldRegistration(): void;
+export declare function enrichContractLoggingConfig(conf: Partial<LoggingConfig> | undefined, ctx?: Ctx): (Partial<LoggingConfig> & {
+    user?: string;
+}) | undefined;
+export declare function extractUserFromIdentity(id?: string): string | undefined;
+export declare function trimCorrelationId(id?: string): string | undefined;

package/lib/esm/contract/logging-context.js

@@ -0,0 +1,71 @@
+import { Logging } from "@decaf-ts/logging";
+let userFieldRegistered = false;
+export function ensureContractLogFieldRegistration() {
+    if (userFieldRegistered)
+        return;
+    userFieldRegistered = true;
+    Logging.register({
+        key: "correlationId",
+        shouldInclude(payload) {
+            const value = payload?.correlationId ?? payload?.config?.correlationId;
+            return Boolean(value);
+        },
+        render(payload) {
+            const value = payload?.correlationId ?? payload?.config?.correlationId;
+            return value === undefined || value === null
+                ? undefined
+                : `, correlationId: ${String(value)}`;
+        },
+        style(rendered, payload) {
+            return payload.applyTheme(rendered, "id");
+        },
+    });
+    Logging.register({
+        key: "user",
+        shouldInclude(payload) {
+            const value = payload?.user ?? payload?.config?.user;
+            return Boolean(value);
+        },
+        render(payload) {
+            const value = payload?.user ?? payload?.config?.user;
+            return value === undefined || value === null
+                ? undefined
+                : `, user: ${String(value)}`;
+        },
+        style(rendered, payload) {
+            return payload.applyTheme(rendered, "id");
+        },
+    });
+}
+export function enrichContractLoggingConfig(conf, ctx) {
+    if (!ctx)
+        return conf;
+    const txId = ctx.stub?.getTxID?.();
+    const compactTxId = trimCorrelationId(txId);
+    const user = extractUserFromIdentity(ctx.clientIdentity?.getID?.());
+    const useDefaultFabricFormatting = !conf?.pattern;
+    return {
+        ...(conf || {}),
+        correlationId: conf?.correlationId || compactTxId,
+        user: conf?.user || user,
+        pattern: conf?.pattern || "{message}{user}{correlationId} {stack}",
+        logLevel: useDefaultFabricFormatting ? false : conf?.logLevel,
+        timestamp: useDefaultFabricFormatting ? false : conf?.timestamp,
+        context: useDefaultFabricFormatting ? false : conf?.context,
+        separator: useDefaultFabricFormatting ? "" : conf?.separator,
+    };
+}
+export function extractUserFromIdentity(id) {
+    if (!id)
+        return undefined;
+    const emailMatch = id.match(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/);
+    return emailMatch?.[0];
+}
+export function trimCorrelationId(id) {
+    if (!id)
+        return undefined;
+    if (id.length <= 10)
+        return id;
+    return `${id.slice(0, 5)}-${id.slice(-5)}`;
+}
+//# sourceMappingURL=data:application/json;base64,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