Debug & Monitor

EdgeFlow provides powerful debugging and monitoring tools to help you develop, test, and maintain your automations effectively.

Debug Panel

The Debug Panel at the bottom of the Flow Editor shows real-time output from Debug nodes and system messages.

Debug Message Types

Panel Controls

Using Debug Nodes

Add Debug nodes to your flow to output message data to the Debug Panel.

Debug Node Configuration

Best Practice: Strategic Debug Placement

Monitor Tab

The Monitor tab shows real-time status of your flows and nodes.

Executions Page

View detailed execution history on the Executions page (accessible from the main navigation).

Execution Details

• Timestamp - When the execution started
• Flow Name - Which flow ran
• Duration - How long execution took
• Status - Success, Error, or Running
• Node Path - Nodes executed in order
• Input/Output Data - Message data at each step

Common Issues & Solutions

Performance Monitoring

Monitor system performance in the Dashboard and identify bottlenecks:

Performance Tips

• Disable Debug nodes in production to reduce overhead
• Use rate limiting on high-frequency triggers
• Avoid storing large data in flow context
• Split complex flows into smaller, focused flows

Advanced Debug Panel Features

The Debug Panel is powered by real-time WebSocket streaming. It subscribes to execution and node_status events, delivering instant feedback as your flows run.

Message Filtering

Filter debug messages by level and by source node to focus on what matters:

{ "payload": 42.8, "topic": "sensors/temp" }

{ "payload": 42.8, "warning": true }

Key Capabilities

• Real-time streaming — Messages arrive instantly via WebSocket (execution and node_status events)
• Level filtering — Toggle visibility for info, warn, error, debug, and success levels
• Node filtering — Show messages from a specific node only
• Search — Full-text search across all message content
• Expandable messages — Click any message to view full input, output, and error details
• Execution time — Per-node execution duration displayed on each message
• Copy to clipboard — One-click copy of any message data
• 300-message buffer — Oldest messages are removed automatically to conserve memory

Execution Context

Every flow execution is tracked by an ExecutionContext, which records the FlowID, ExecutionID, StartTime, Variables (local and global), and per-node states.

Node State

Each node within an execution maintains a NodeState containing:

• NodeID — Unique identifier for the node
• Status — Current state (pending, running, completed, error)
• StartTime / EndTime / Duration — Timing information
• Error — Error message if the node failed
• Input data — The message received by the node
• Output data — The message produced by the node
• ExecutionCount — How many times this node has run

Context Inspection in a Function Node

// Access flow context
const count = flow.get('executionCount') || 0;
flow.set('executionCount', count + 1);

// Access node context
const lastValue = context.get('lastReading');
context.set('lastReading', msg.payload);

// Access global context
const config = global.get('systemConfig');

Context Store

EdgeFlow provides three variable scopes for storing data that persists across messages:

Storage Backends

Context Methods

Error Handling Patterns

EdgeFlow provides built-in mechanisms for catching and handling errors in your flows.

Catch Nodes

A Catch node intercepts errors thrown by other nodes. You can configure it to catch errors from specific nodes or from all nodes within a flow.

Error Message Structure

When an error is caught, the message includes an error object:

msg.error = {
  message: "Connection refused",
  source: {
    id: "node-abc123",
    type: "mqtt-out",
    name: "MQTT Publisher"
  }
}

Error Handling Flow

Status Nodes

Status nodes allow you to monitor node status changes programmatically. When a node changes its status (e.g., connected, disconnected, error), the Status node receives a message you can route to logging, alerts, or dashboards.

Real-Time WebSocket Events

EdgeFlow uses a central WebSocket hub at /ws to broadcast real-time events to all connected clients. Each client maintains a 256-message send buffer.

Event Types

Connection Details

• Endpoint — WebSocket at /ws (main hub)
• Send buffer — 256 messages per client
• Keepalive — 30-second ping interval
• Reconnect — Clients auto-reconnect on disconnect