@urga-panel/ur-panels-core 1.0.20 → 1.0.22

package/src/services/main/logService/transports/DatabaseTransport.ts

@@ -0,0 +1,116 @@
+import { ILogEntry, ILogTransport } from "../types";
+import { LogLevel } from "../../../../types/Service";
+
+export interface DatabaseTransportOptions {
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    getDatabaseService: () => any; // DatabaseService'i almak için callback
+    collectionName?: string; // Varsayılan: "logs"
+    batchSize?: number; // Toplu yazma için
+    flushInterval?: number; // ms cinsinden
+}
+
+export class DatabaseTransport implements ILogTransport {
+    name = "DatabaseTransport";
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    
+    private getDatabaseService: () => any;
+    private collectionName: string;
+    private batchSize: number;
+    private flushInterval: number;
+    private logBuffer: ILogEntry[] = [];
+    private flushTimer?: NodeJS.Timeout;
+    
+    private logLevelOrder: Record<LogLevel, number> = {
+        debug: 0,
+        info: 1,
+        success: 2,
+        warn: 3,
+        error: 4
+    };
+    
+    constructor(options: DatabaseTransportOptions) {
+        this.getDatabaseService = options.getDatabaseService;
+        this.collectionName = options.collectionName || "logs";
+        this.batchSize = options.batchSize || 10;
+        this.flushInterval = options.flushInterval || 5000; // 5 saniye
+        
+        if (options.levels) this.levels = options.levels;
+        if (options.minLevel) this.minLevel = options.minLevel;
+        
+        // Periyodik flush başlat
+        this.startFlushTimer();
+    }
+    
+    shouldLog(entry: ILogEntry): boolean {
+        // Eğer spesifik level'lar belirtilmişse
+        if (this.levels && this.levels.length > 0) {
+            return this.levels.includes(entry.level);
+        }
+        
+        // Eğer minimum level belirtilmişse
+        if (this.minLevel) {
+            return this.logLevelOrder[entry.level] >= this.logLevelOrder[this.minLevel];
+        }
+        
+        // Varsayılan: sadece warn ve error
+        return entry.level === 'warn' || entry.level === 'error';
+    }
+    
+    async log(entry: ILogEntry): Promise<void> {
+        // Buffer'a ekle
+        this.logBuffer.push(entry);
+        
+        // Eğer buffer dolmuşsa hemen flush et
+        if (this.logBuffer.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    
+    async flush(): Promise<void> {
+        if (this.logBuffer.length === 0) return;
+        
+        try {
+            const dbService = this.getDatabaseService();
+            if (!dbService || !dbService.client) {
+                console.error('[DatabaseTransport] DatabaseService not ready');
+                return;
+            }
+            
+            const db = dbService.client.db();
+            const logsCollection = db.collection(this.collectionName);
+            
+            const documents = this.logBuffer.map(entry => ({
+                timestamp: entry.timestamp,
+                level: entry.level,
+                service: entry.tag,
+                namespace: entry.namespace,
+                message: entry.message,
+                args: entry.args,
+                createdAt: new Date()
+            }));
+            
+            await logsCollection.insertMany(documents);
+            this.logBuffer = []; // Buffer'ı temizle
+        } catch (error) {
+            console.error('[DatabaseTransport] Failed to write logs:', error);
+        }
+    }
+    
+    async close(): Promise<void> {
+        // Timer'ı durdur
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        
+        // Kalan log'ları flush et
+        await this.flush();
+    }
+    
+    private startFlushTimer(): void {
+        this.flushTimer = setInterval(async () => {
+            await this.flush();
+        }, this.flushInterval);
+    }
+}

package/src/services/main/logService/types.ts

@@ -0,0 +1,26 @@
+import { LogLevel } from "../../../types/Service";
+
+export interface ILogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    tag: string;
+    namespace?: string;
+    message: string;
+    args: any[];
+}
+
+export interface ILogTransport {
+    name: string;
+    levels?: LogLevel[]; // Eğer belirtilirse, sadece bu level'ları logla
+    minLevel?: LogLevel; // Eğer belirtilirse, bu level ve üstü
+    shouldLog(entry: ILogEntry): boolean; // Transport log'u kabul ediyor mu?
+    log(entry: ILogEntry): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    close?(): void | Promise<void>;
+}
+
+export interface LogServiceConfig {
+    transports: ILogTransport[];
+    minLevel?: LogLevel;
+    enabledNamespaces?: string[]; // ['template:kurs', 'DatabaseService']
+}

package/src/services/main/logService/utils/parseEnvConfig.ts

@@ -0,0 +1,78 @@
+import { LogLevel } from "../../../../types/Service";
+import { LogServiceConfig } from "../types";
+import { ConsoleTransport } from "../transports/ConsoleTransport";
+
+export interface EnvLogConfig {
+    LOG_LEVEL?: string;
+    LOG_CONSOLE_LEVELS?: string;
+    LOG_NAMESPACES?: string;
+    LOG_DATABASE_ENABLED?: string;
+    LOG_DATABASE_LEVELS?: string;
+}
+
+/**
+ * Environment variable'lardan LogService config'i oluşturur
+ * 
+ * Örnek .env:
+ * LOG_LEVEL=info
+ * LOG_CONSOLE_LEVELS=debug,info,success,warn,error
+ * LOG_NAMESPACES=DatabaseService,AuthService
+ * LOG_DATABASE_ENABLED=true
+ * LOG_DATABASE_LEVELS=warn,error
+ */
+export function parseLogConfigFromEnv(env: EnvLogConfig): Partial<LogServiceConfig> {
+    const config: Partial<LogServiceConfig> = {
+        transports: []
+    };
+
+    // Minimum log level
+    if (env.LOG_LEVEL) {
+        const level = env.LOG_LEVEL.toLowerCase();
+        if (['debug', 'info', 'success', 'warn', 'error'].includes(level)) {
+            config.minLevel = level as LogLevel;
+        }
+    }
+
+    // Namespace filtreleme
+    if (env.LOG_NAMESPACES) {
+        config.enabledNamespaces = env.LOG_NAMESPACES
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+    }
+
+    // ConsoleTransport (varsayılan olarak her zaman var)
+    let consoleLevels: LogLevel[] | undefined;
+    if (env.LOG_CONSOLE_LEVELS) {
+        consoleLevels = env.LOG_CONSOLE_LEVELS
+            .split(',')
+            .map(s => s.trim().toLowerCase())
+            .filter(s => ['debug', 'info', 'success', 'warn', 'error'].includes(s)) as LogLevel[];
+    }
+    
+    config.transports!.push(new ConsoleTransport({ 
+        levels: consoleLevels 
+    }));
+
+    return config;
+}
+
+/**
+ * DatabaseTransport için config döner
+ */
+export function getDatabaseTransportConfigFromEnv(env: EnvLogConfig): { enabled: boolean, levels?: LogLevel[] } {
+    const enabled = env.LOG_DATABASE_ENABLED === 'true';
+    
+    let levels: LogLevel[] | undefined;
+    if (env.LOG_DATABASE_LEVELS) {
+        levels = env.LOG_DATABASE_LEVELS
+            .split(',')
+            .map(s => s.trim().toLowerCase())
+            .filter(s => ['debug', 'info', 'success', 'warn', 'error'].includes(s)) as LogLevel[];
+    } else {
+        // Varsayılan: sadece warn ve error
+        levels = ['warn', 'error'];
+    }
+    
+    return { enabled, levels };
+}

package/src/services/main/remoteApiControllerService/RemoteApiControllerService.ts

@@ -46,11 +46,11 @@ export class RemoteApiControllerService extends Service {
     }
     addApi(apiName: string, serviceRef: any, apiConfig: apiConfig): void {
         if (this.apis[apiName]) {
-            console.warn(`API ${apiName} already exists. Overwriting.`);
+            this.log.warn(`API ${apiName} already exists. Overwriting.`);
         }
         this.apis[apiName] = apiConfig;
         this.apis[apiName].serviceRef = serviceRef;
-        console.log(`API ${apiName} added with config:`, apiConfig);
+        this.log.info(`API ${apiName} added with config:`, apiConfig);
 
         // Create a service for each API
         Object.keys(this.apis).forEach(async apiName => {

package/src/services/main/testServices/TestService2.ts

@@ -13,7 +13,7 @@ export class Test2Service extends Service {
     serviceInfo: { name: string; requiredServices: string[]; };
     constructor(ots:Test2Ots) {
         super({...ots});
-        console.log("Test2Service initialized");
+        this.log.info("Test2Service initialized");
     }
 
     protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {

package/src/types/Service.ts

@@ -2,6 +2,21 @@ import { ServiceOts } from "./ServiceOts";
 import { ServiceResponse } from "./ServiceResponse";
 import { ServiceSetupOptions } from "./ServiceSetupOptions";
 
+export type LogLevel = 'debug' | 'info' | 'success' | 'warn' | 'error';
+
+export interface ServiceLogger {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    success: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    // Backward compatibility
+    OK: (...args: any[]) => void;
+    ERROR: (...args: any[]) => void;
+    WARN: (...args: any[]) => void;
+    l: (...args: any[]) => void;
+}
+
 export abstract class Service {
 
     static serviceInfo: {
@@ -9,12 +24,8 @@ export abstract class Service {
         requiredServices: string[];
     }
     public tag: string = "";
-    public log: {
-        OK: Function,
-        ERROR: Function,
-        l: Function,
-        WARN: Function
-    }
+    public namespace?: string;
+    public log: ServiceLogger;
 
     protected abstract onSetup(options?: ServiceSetupOptions):Promise<ServiceResponse>;
     protected abstract onStart(): Promise<ServiceResponse>;
@@ -40,22 +51,51 @@ export abstract class Service {
 
     constructor(private opts: ServiceOts) {
         this.tag = opts.tag;
+        this.namespace = opts.namespace;
+        
         if (!opts.usedService["LogService"]) {
-            //console.error("LogService not found for", opts.tag);
             this.log = this.logSetup();
             return;
         }
         else {
-            //console.log("LogService found for", opts.usedService["LogService"]);
-            this.log = (opts.usedService["LogService"] as unknown as any).logSetupForService(this.tag);
+            this.log = (opts.usedService["LogService"] as unknown as any).logSetupForService(this.tag, this.namespace);
         }
     }
-    logSetup() {
+    
+    private getLogPrefix(): string {
+        if (this.namespace) {
+            return `[${this.namespace}:${this.tag}]`;
+        }
+        return `[${this.tag}]`;
+    }
+    
+    private formatMessage(level: LogLevel, ...args: any[]): any[] {
+        const timestamp = new Date().toLocaleTimeString('tr-TR', { hour12: false });
+        const prefix = this.getLogPrefix();
+        
+        const icons: Record<LogLevel, string> = {
+            debug: '🔍',
+            info: 'ℹ️',
+            success: '✅',
+            warn: '⚠️',
+            error: '❌'
+        };
+        
+        return [`${icons[level]} ${timestamp} ${prefix}`, ...args];
+    }
+    
+    logSetup(): ServiceLogger {
         return {
-            OK: console.log.bind(console, `[${this.tag}]` + "-[OK]"),
-            ERROR: console.error.bind(console, `[${this.tag}]` + "-[ERROR]"),
-            WARN: console.warn.bind(console, `[${this.tag}]` + "-[WARN]"),
-            l: console.log.bind(console, `[${this.tag}]`),
+            debug: (...args: any[]) => console.log(...this.formatMessage('debug', ...args)),
+            info: (...args: any[]) => console.log(...this.formatMessage('info', ...args)),
+            success: (...args: any[]) => console.log(...this.formatMessage('success', ...args)),
+            warn: (...args: any[]) => console.warn(...this.formatMessage('warn', ...args)),
+            error: (...args: any[]) => console.error(...this.formatMessage('error', ...args)),
+            // Backward compatibility
+            OK: (...args: any[]) => console.log(...this.formatMessage('success', ...args)),
+            ERROR: (...args: any[]) => console.error(...this.formatMessage('error', ...args)),
+            WARN: (...args: any[]) => console.warn(...this.formatMessage('warn', ...args)),
+            l: (...args: any[]) => console.log(...this.formatMessage('info', ...args)),
         }
     }
 }

package/src/types/ServiceOts.ts

@@ -6,6 +6,7 @@ export type ServiceOts = {
         [key: string]: () => Service
     },
     tag:string,
+    namespace?: string,
     abilities?: {
         createChildService?: (tag:string, PageCtor: ServiceConstructor<Service>)=> Service,
     }