Event Debugger

Debug and monitor QBCore events in real-time with advanced filtering, logging, and analysis capabilities.

Overview

The Event Debugger provides comprehensive monitoring of QBCore events, allowing developers to track event flow, debug issues, and optimize event handling. Monitor client/server events, network events, and custom triggers with detailed logging and performance metrics.

Debugging Features

Real-Time Monitoring

• Live Event Stream: Monitor events as they happen in real-time
• Event Filtering: Filter by event type, source, or search terms
• Performance Tracking: Monitor response times and performance metrics
• Status Monitoring: Track success, warning, and error states

Event Analysis

• Event Details: Inspect event data, parameters, and responses
• Source Tracking: Identify which resource triggered each event
• Response Time Analysis: Monitor event execution performance
• Error Detection: Automatically highlight failed or slow events

Advanced Filtering

-- Filter events by pattern
EventDebugger.filter({
    pattern = "police:*",        -- All police events
    type = "server",             -- Server-side events only
    minResponseTime = 100,       -- Events slower than 100ms
    status = "error"             -- Failed events only
})

Data Export

• JSON Export: Export events for external analysis
• CSV Format: Import into spreadsheet applications
• Log Integration: Compatible with standard logging tools
• Report Generation: Generate debugging reports

Common Event Patterns

QBCore Core Events

-- Player events
'QBCore:Client:OnPlayerLoaded'
'QBCore:Client:OnPlayerUnload'
'QBCore:Client:OnJobUpdate'
'QBCore:Client:OnGangUpdate'
 
-- Server events
'QBCore:Server:PlayerLoaded'
'QBCore:Server:OnPlayerUnload'
'QBCore:Server:SetPlayerData'
'QBCore:Server:OnJobUpdate'

Inventory Events

-- Client events
'inventory:client:openInventory'
'inventory:client:closeInventory'
'inventory:client:ItemBox'
 
-- Server events
'inventory:server:OpenInventory'
'inventory:server:UseItem'
'inventory:server:AddItem'
'inventory:server:RemoveItem'

Banking Events

-- Client events
'banking:client:openBankingApp'
'banking:client:doTransaction'
 
-- Server events
'banking:server:Transaction'
'banking:server:GetAccount'
'banking:server:CreateAccount'

Performance Analysis

Response Time Monitoring

-- Typical response times by event type
local performanceThresholds = {
    ['client'] = 50,      -- Client events should be < 50ms
    ['server'] = 100,     -- Server events should be < 100ms
    ['network'] = 200     -- Network events should be < 200ms
}

Memory Usage Tracking

-- Monitor memory usage during events
RegisterNetEvent('event:monitor:memory', function()
    local memBefore = collectgarbage('count')
    -- Event execution
    local memAfter = collectgarbage('count')
    local memDiff = memAfter - memBefore
    
    if memDiff > 100 then -- More than 100KB
        print(('Memory spike detected: %d KB'):format(memDiff))
    end
end)

Event Frequency Analysis

-- Track event frequency
local eventCounts = {}
local function trackEventFrequency(eventName)
    eventCounts[eventName] = (eventCounts[eventName] or 0) + 1
    
    -- Alert if event fires too frequently
    if eventCounts[eventName] > 100 then
        print(('High frequency event detected: %s (%d times)'):format(eventName, eventCounts[eventName]))
    end
end

Debugging Strategies

Event Flow Tracing

1. Start Monitoring: Begin event capture before reproducing the issue
2. Reproduce Issue: Perform the action that causes the problem
3. Analyze Sequence: Review the event sequence leading to the issue
4. Identify Bottleneck: Find slow or failing events in the chain

Performance Debugging

1. Baseline Measurement: Establish normal performance metrics
2. Load Testing: Monitor events under various load conditions
3. Bottleneck Identification: Find events with high response times
4. Optimization: Implement fixes and measure improvements

Error Tracking

1. Error Categorization: Group errors by type and frequency
2. Root Cause Analysis: Trace errors back to their source
3. Pattern Recognition: Identify common error conditions
4. Prevention: Implement checks to prevent recurring errors

Integration Examples

Custom Event Logging

-- Client-side event logging
local function logEvent(eventName, data, responseTime)
    TriggerServerEvent('eventDebugger:logEvent', {
        name = eventName,
        type = 'client',
        source = GetCurrentResourceName(),
        data = data,
        responseTime = responseTime,
        timestamp = os.time()
    })
end
 
-- Server-side event logging
RegisterNetEvent('eventDebugger:logEvent', function(eventData)
    -- Store in database or send to monitoring service
    MySQL.insert('INSERT INTO event_logs (name, type, source, data, response_time, timestamp) VALUES (?, ?, ?, ?, ?, ?)', {
        eventData.name,
        eventData.type,
        eventData.source,
        json.encode(eventData.data),
        eventData.responseTime,
        eventData.timestamp
    })
end)

Automated Alerting

-- Alert on performance issues
local function checkPerformance(eventName, responseTime)
    local threshold = performanceThresholds[eventType] or 100
    
    if responseTime > threshold then
        -- Send alert to Discord/Slack
        sendAlert(('Performance Alert: %s took %dms (threshold: %dms)'):format(
            eventName, responseTime, threshold
        ))
    end
end

Troubleshooting

High Response Times

1. Check Server Load: Monitor CPU and memory usage
2. Database Performance: Analyze database query execution times
3. Network Issues: Check for network latency or packet loss
4. Resource Conflicts: Identify conflicting resources

Event Failures

1. Parameter Validation: Ensure correct event parameters
2. Resource Dependencies: Verify all required resources are loaded
3. Permission Checks: Confirm proper player permissions
4. Error Logs: Check server console for detailed error messages

Memory Leaks

1. Event Cleanup: Ensure events are properly unregistered
2. Data References: Check for circular references in event data
3. Garbage Collection: Monitor garbage collection patterns
4. Resource Restart: Identify resources that need periodic restarts

Pro Tip: Use the Event Debugger during development to optimize event handling and catch issues before they reach production. Set up automated monitoring in production for ongoing performance tracking.

Need help with event debugging? Check our debugging guide or visit our developer forum.