fix: remove all debug logging statements from production code

- Remove logger.debug statements from worker-discovery.service.ts
- Remove logger.debug statements from worker-proxy.ts
- Remove logger.debug statements from worker-provider.factory.ts
- Eliminates unnecessary debug output in production environments
- Improves performance by removing debug logging overhead
- Provides cleaner, professional library behavior

Author: kauandotnet

lib/providers/worker-provider.factory.ts

@@ -1,7 +1,7 @@
-import { Logger, type Provider, type Type } from '@nestjs/common';
-import { WORKER_INJECT_TOKEN } from '../constants/worker.constants';
-import { WorkerManager } from '../managers/worker-manager';
-import { WorkerProxy } from '../proxy/worker-proxy';
+import { Logger, type Provider, type Type } from "@nestjs/common";
+import { WORKER_INJECT_TOKEN } from "../constants/worker.constants";
+import { WorkerManager } from "../managers/worker-manager";
+import { WorkerProxy } from "../proxy/worker-proxy";
 
 export class WorkerProviderFactory {
   private static readonly logger = new Logger(WorkerProviderFactory.name);
@@ -15,8 +15,6 @@ export class WorkerProviderFactory {
     return {
       provide: token,
       useFactory: (workerManager: WorkerManager) => {
-        WorkerProviderFactory.logger.debug(`Creating worker proxy for ${workerClass.name}`);
-
         const proxy = new WorkerProxy(workerClass, workerManager);
         return proxy.createProxy();
       },
@@ -29,20 +27,21 @@ export class WorkerProviderFactory {
    */
   static createWorkerProviders(workerClasses: Type<unknown>[]): Provider[] {
     return workerClasses.map((workerClass) =>
-      WorkerProviderFactory.createWorkerProvider(workerClass),
+      WorkerProviderFactory.createWorkerProvider(workerClass)
     );
   }
 
   /**
    * Create a dynamic provider for a worker class
    * This is useful when the worker class is determined at runtime
    */
-  static createDynamicWorkerProvider(token: string, workerClass: Type<unknown>): Provider {
+  static createDynamicWorkerProvider(
+    token: string,
+    workerClass: Type<unknown>
+  ): Provider {
     return {
       provide: token,
       useFactory: (workerManager: WorkerManager) => {
-        WorkerProviderFactory.logger.debug(`Creating dynamic worker proxy for ${workerClass.name}`);
-
         const proxy = new WorkerProxy(workerClass, workerManager);
         return proxy.createProxy();
       },
@@ -62,7 +61,7 @@ export class WorkerProviderFactory {
    */
   static createWorkerFactory(): Provider {
     return {
-      provide: 'WORKER_FACTORY',
+      provide: "WORKER_FACTORY",
       useFactory: (workerManager: WorkerManager) => {
         return (workerClass: Type<unknown>) => {
           const proxy = new WorkerProxy(workerClass, workerManager);

lib/proxy/worker-proxy.ts

@@ -55,20 +55,13 @@ export class WorkerProxy {
   ) {
     return async (...args: unknown[]) => {
       try {
-        this.logger.debug(
-          `Executing worker method ${this.workerClass.name}.${methodName}`
-        );
-
         const result = await this.workerManager.executeWorkerMethod(
           this.workerClass,
           methodName,
           args,
           methodOptions
         );
 
-        this.logger.debug(
-          `Worker method ${this.workerClass.name}.${methodName} completed`
-        );
         return result;
       } catch (error) {
         this.logger.error(

lib/services/worker-discovery.service.ts

@@ -39,22 +39,8 @@ export class WorkerDiscoveryService implements OnModuleInit {
 
     let discoveredCount = 0;
 
-    this.logger.debug(`Total wrappers found: ${allWrappers.length}`);
-
     for (const wrapper of allWrappers) {
-      if (wrapper.metatype) {
-        this.logger.debug(`Checking wrapper: ${wrapper.metatype.name}`);
-        const hasWorkerMetadata = Reflect.getMetadata(
-          "isWorker",
-          wrapper.metatype
-        );
-        this.logger.debug(
-          `${wrapper.metatype.name} has worker metadata: ${hasWorkerMetadata}`
-        );
-      }
-
       if (this.isWorkerWrapper(wrapper)) {
-        this.logger.debug(`Found worker: ${wrapper.metatype?.name}`);
         await this.registerWorkerFromWrapper(wrapper);
         discoveredCount++;
       }