flowscale 1.0.17-beta.6 → 1.0.17-beta.8

package/README.md

@@ -421,6 +421,47 @@ console.log('All Runs:', allRuns);
 - Always store sensitive information such as API keys in environment variables.
 - Use `.env` files and libraries like `dotenv` for easy environment management.
 
+### Logging Configuration
+The SDK includes configurable logging to help with debugging and monitoring. By default, logging is enabled with the 'info' level.
+
+#### Configuration Options
+```javascript
+const flowscale = new FlowscaleAPI({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://your-api-url.pod.flowscale.ai',
+  enableLogging: true,        // Enable/disable logging (default: true)
+  logLevel: 'info'           // Set log level: 'debug', 'info', 'warn', 'error' (default: 'info')
+});
+```
+
+#### Dynamic Logging Control
+You can also change logging settings after initialization:
+
+```javascript
+// Enable debug logging
+flowscale.setLoggingConfig(true, 'debug');
+
+// Disable logging completely
+flowscale.setLoggingConfig(false);
+
+// Check current logging configuration
+const loggingConfig = flowscale.getLoggingConfig();
+console.log(loggingConfig); // { enabled: true, level: 'debug' }
+```
+
+#### Log Levels
+- **debug**: Most verbose, includes detailed operation information
+- **info**: General information about operations (default)
+- **warn**: Warning messages for potential issues
+- **error**: Only error messages
+
+#### Log Format
+All logs are prefixed with timestamp and level:
+```
+[Flowscale INFO] 2025-06-03T10:30:45.123Z: WebSocket connection established
+[Flowscale DEBUG] 2025-06-03T10:30:46.456Z: Polling workflow output: {...}
+```
+
 ### Error Handling
 - Wrap API calls in try-catch blocks to handle errors gracefully.
 - Log errors for debugging and improve resilience.

package/dist/index.d.ts

@@ -9,6 +9,8 @@ export declare class FlowscaleAPI {
     private ws;
     private wsConnected;
     private reconnectAttempts;
+    private enableLogging;
+    private logLevel;
     constructor(config: FlowscaleConfig);
     /**
      * Checks the health status of all ComfyUI instances within the specified cluster.
@@ -71,6 +73,14 @@ export declare class FlowscaleAPI {
      * Error handling helper.
      */
     private handleError;
+    /**
+     * Internal logging methods
+     */
+    private log;
+    private logDebug;
+    private logInfo;
+    private logWarn;
+    private logError;
     /**
      * Makes API request with retry capability for browser environments
      */
@@ -96,4 +106,18 @@ export declare class FlowscaleAPI {
      * @returns True if the WebSocket is connected, false otherwise
      */
     isWebSocketConnected(): boolean;
+    /**
+     * Configure logging settings dynamically
+     * @param enabled Whether to enable logging
+     * @param level Log level to use ('debug', 'info', 'warn', 'error')
+     */
+    setLoggingConfig(enabled: boolean, level?: 'debug' | 'info' | 'warn' | 'error'): void;
+    /**
+     * Get current logging configuration
+     * @returns Object with current logging settings
+     */
+    getLoggingConfig(): {
+        enabled: boolean;
+        level: "debug" | "info" | "warn" | "error";
+    };
 }

package/dist/index.js

@@ -35,6 +35,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -62,6 +71,8 @@ var FlowscaleAPI = /** @class */ (function () {
         this.baseUrl = config.baseUrl;
         this.maxRetries = config.maxRetries || 3;
         this.retryDelay = config.retryDelay || 1000;
+        this.enableLogging = config.enableLogging !== false; // Default to true for backward compatibility
+        this.logLevel = config.logLevel || 'info';
         this.client = axios_1.default.create({
             baseURL: this.baseUrl,
             timeout: config.timeout || 6000000, // Default 6000s timeout instead of Axios default 0 (no timeout)
@@ -184,11 +195,13 @@ var FlowscaleAPI = /** @class */ (function () {
                         return [4 /*yield*/, this.getOutput(outputName)];
                     case 4:
                         output = _c.sent();
-                        console.log("DEBUG:", output);
-                        if (output) {
-                            if (output.status === 'success') {
-                                return [2 /*return*/, output]; // Return the output if successful
-                            }
+                        this.logDebug("Polling workflow output:", output);
+                        if (output === null) {
+                            this.logWarn("No output found for ".concat(outputName, ", retrying..."));
+                            return [3 /*break*/, 2]; // No output yet, continue polling
+                        }
+                        if (output.status === 'success') {
+                            return [2 /*return*/, output]; // Return the output if successful
                         }
                         return [3 /*break*/, 6];
                     case 5:
@@ -322,6 +335,66 @@ var FlowscaleAPI = /** @class */ (function () {
         // Something else happened
         throw new Error("Error: ".concat(error.message));
     };
+    /**
+     * Internal logging methods
+     */
+    FlowscaleAPI.prototype.log = function (level, message) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        if (!this.enableLogging)
+            return;
+        var levels = ['debug', 'info', 'warn', 'error'];
+        var currentLevelIndex = levels.indexOf(this.logLevel);
+        var messageLevelIndex = levels.indexOf(level);
+        if (messageLevelIndex >= currentLevelIndex) {
+            var timestamp = new Date().toISOString();
+            var prefix = "[Flowscale ".concat(level.toUpperCase(), "] ").concat(timestamp, ":");
+            switch (level) {
+                case 'debug':
+                    console.log.apply(console, __spreadArray([prefix, message], args, false));
+                    break;
+                case 'info':
+                    console.info.apply(console, __spreadArray([prefix, message], args, false));
+                    break;
+                case 'warn':
+                    console.warn.apply(console, __spreadArray([prefix, message], args, false));
+                    break;
+                case 'error':
+                    console.error.apply(console, __spreadArray([prefix, message], args, false));
+                    break;
+            }
+        }
+    };
+    FlowscaleAPI.prototype.logDebug = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.log.apply(this, __spreadArray(['debug', message], args, false));
+    };
+    FlowscaleAPI.prototype.logInfo = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.log.apply(this, __spreadArray(['info', message], args, false));
+    };
+    FlowscaleAPI.prototype.logWarn = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.log.apply(this, __spreadArray(['warn', message], args, false));
+    };
+    FlowscaleAPI.prototype.logError = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.log.apply(this, __spreadArray(['error', message], args, false));
+    };
     /**
      * Makes API request with retry capability for browser environments
      */
@@ -429,7 +502,7 @@ var FlowscaleAPI = /** @class */ (function () {
         this.reconnectAttempts = 0;
         // Set up event handlers
         this.ws.onopen = function () {
-            console.log('WebSocket connection established');
+            _this.logInfo('WebSocket connection established');
             _this.wsConnected = true;
             _this.reconnectAttempts = 0;
             if (options.onOpen)
@@ -442,18 +515,18 @@ var FlowscaleAPI = /** @class */ (function () {
                     options.onMessage(message);
             }
             catch (error) {
-                console.error('Failed to parse WebSocket message:', error);
+                _this.logError('Failed to parse WebSocket message:', error);
                 if (options.onError)
                     options.onError(new ErrorEvent('error', { error: error }));
             }
         };
         this.ws.onclose = function (event) {
-            console.log("WebSocket connection closed: ".concat(event.code, " ").concat(event.reason));
+            _this.logInfo("WebSocket connection closed: ".concat(event.code, " ").concat(event.reason));
             _this.wsConnected = false;
             // Attempt to reconnect if enabled
             if (reconnect && _this.reconnectAttempts < maxReconnectAttempts) {
                 _this.reconnectAttempts++;
-                console.log("Attempting to reconnect (".concat(_this.reconnectAttempts, "/").concat(maxReconnectAttempts, ")..."));
+                _this.logInfo("Attempting to reconnect (".concat(_this.reconnectAttempts, "/").concat(maxReconnectAttempts, ")..."));
                 setTimeout(function () {
                     _this.connectWebSocket(options);
                 }, reconnectInterval);
@@ -506,6 +579,27 @@ var FlowscaleAPI = /** @class */ (function () {
     FlowscaleAPI.prototype.isWebSocketConnected = function () {
         return this.wsConnected && this.ws !== null && this.ws.readyState === WebSocket.OPEN;
     };
+    /**
+     * Configure logging settings dynamically
+     * @param enabled Whether to enable logging
+     * @param level Log level to use ('debug', 'info', 'warn', 'error')
+     */
+    FlowscaleAPI.prototype.setLoggingConfig = function (enabled, level) {
+        this.enableLogging = enabled;
+        if (level) {
+            this.logLevel = level;
+        }
+    };
+    /**
+     * Get current logging configuration
+     * @returns Object with current logging settings
+     */
+    FlowscaleAPI.prototype.getLoggingConfig = function () {
+        return {
+            enabled: this.enableLogging,
+            level: this.logLevel
+        };
+    };
     return FlowscaleAPI;
 }());
 exports.FlowscaleAPI = FlowscaleAPI;

package/dist/types.d.ts

@@ -93,6 +93,8 @@ export interface FlowscaleConfig {
     timeout?: number;
     maxRetries?: number;
     retryDelay?: number;
+    enableLogging?: boolean;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
 }
 export type WebSocketEventCallback = (data: any) => void;
 export interface WebSocketMessage {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowscale",
-  "version": "1.0.17-beta.6",
+  "version": "1.0.17-beta.8",
   "description": "An NPM library for communicating with the Flowscale APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",