Documentation

System Requirements

Before installing Sentinel, ensure your WordPress site meets these requirements:

• WordPress: Version 5.0 or higher
• PHP: Version 7.4 or higher
• MySQL: Version 5.6 or higher
• Memory: Minimum 64MB PHP memory limit

Method 1: WordPress Repository (Coming Soon)

Once approved on WordPress.org, you'll be able to install directly from your admin dashboard.

Navigate to Plugins → Add New → Search for 'Sentinel' → Install & Activate

Method 2: Manual Installation

Download and install the plugin manually for immediate access.

1. Download the plugin ZIP file from our download page
2. Go to Plugins → Add New → Upload Plugin
3. Choose the downloaded file and click Install Now
4. Activate the plugin after installation

Post-Installation Checklist

After installing Sentinel, complete these essential steps:

1. Access the Dashboard

After activation, navigate to Sentinel in your WordPress admin sidebar. You'll see a comprehensive dashboard with real-time activity monitoring.

2. Review Event Settings

Visit Sentinel → Event Registry to customize which events to track. This is where you can enable or disable specific monitoring features based on your security needs.

• User logins/logouts

• Content creation/editing

• Plugin/theme changes

• Failed login attempts

• Admin actions

• File modifications

• Database changes

• Security events

3. Configure Alerts

Set up email notifications for critical security events. Go to Sentinel → Settings → Notifications Tab → Compliance & Monitoring to have sentinel send you an email when a critical security event occurs.

4. Test the System

Perform some test actions on your site to verify that Sentinel is properly logging events:

• Log out and log back in
• Create or edit a post
• Change a setting in your admin panel
• Check the activity log to see these events recorded

Pro Tips for New Users

Basic Configuration

Access general settings via Sentinel → Settings → Log Management Tab → Log Management & Retention. These settings control the fundamental behavior of the monitoring system.

Advanced Configuration Options

Fine-tune Sentinel's behavior with these advanced settings. These options provide more granular control over the monitoring system's behavior and performance.

Event Registry Structure

The Event Registry is organized into three main sections to help you manage different types of monitoring:

Available Event Types

Sentinel tracks and logs a comprehensive range of events that range from PHP errors to WordPress core events. Below is a list of some of what Sentinel tracks. This is not a comprehensive list as most events are self-explanatory.

Batch Logging Configuration

Control how Sentinel processes and stores log entries to balance performance with real-time visibility.

Rate Limiting & Spam Prevention

Protect your site from log spam and potential abuse while maintaining comprehensive monitoring.

Smart Memory Monitoring

Prevent memory-related crashes and optimize resource usage with intelligent memory management.

Performance Optimization by Site Type

Recommended configurations for different types of WordPress sites:

Monitoring Performance Impact

Use Sentinel's built-in performance monitoring to ensure optimal operation:

Overview

Advanced memory leak detection uses sophisticated algorithms to identify potential memory leaks before they cause serious performance issues or crashes.

How It Works

Alert Types

Recommendations Provided

When a memory leak is detected, Sentinel provides context-specific recommendations:

• Urgent Actions: Identify recently changed code, enable debug logging, check for infinite loops
• Investigation Steps: Review activated plugins, check data processing operations
• Optimization Tips: Review image processing, implement pagination, optimize caching strategies

IP Anonymization

Sentinel's intelligent anonymization system masks personally identifiable data in security logs while preserving analytical value for security monitoring and traffic analysis.

Security Response Mode

Configure how Sentinel+ responds to detected security threats using the intuitive 3-way toggle control. This setting determines the system's behavior when thresholds are exceeded.

Detection Thresholds

Configure sensitivity levels for different types of security threats. These settings determine when Sentinel+ considers an activity suspicious enough to trigger an incident.

Brute Force Detection

Monitors repeated login failures from the same IP address within a specified time window.

User Enumeration Detection

Detects attempts to discover valid usernames through login form probing or author page scanning.

XML-RPC Protection

Monitors XML-RPC endpoint for abuse including brute force attacks and DDoS attempts.

IP Allowlist Management

Configure IP addresses and ranges that should bypass all authentication limits and security checks. This is essential for preventing lockouts of legitimate users and systems.

Allowlist Configuration

Enter IP addresses or CIDR ranges in the allowlist textarea, one per line. Supports both individual IPs and network ranges:

# Office network
192.168.1.0/24

# VPN server
203.0.113.5

# CDN ranges
198.51.100.0/24
203.0.113.0/24

# Localhost variants
127.0.0.1
::1

CIDR Notation Examples

Response Settings

Configure how Sentinel+ responds when security incidents are detected based on the selected response mode.

Throttle Response

When "Throttle Threats" mode is active, add configurable delays to suspicious requests:

Block Response

When "Block Threats" mode is active, temporarily block IP addresses that exceed thresholds:

Admin Trust Mode

Reduce false positives by temporarily bypassing security checks for admin users after successful authentication.

Incident Management

Configure automatic incident resolution and notification rate limiting to prevent alert fatigue while maintaining security awareness.

Troubleshooting Security Controls

Common issues and solutions for security control configuration and operation.

Overview

The data deletion request feature allows users to request the removal of their personal data from Sentinel's logs and databases, helping you comply with GDPR Article 17 (Right to Erasure).

Implementation

Add the shortcode to any page where users can request data deletion:

// Add to your privacy policy page or dedicated deletion request page

[sentinel_data_deletion_request]

// Customize the deletion request form

add_filter('sentinel_data_deletion_form', function($form_html, $user_id) {

    // Customize form appearance or add additional fields

    return $form_html;

}, 10, 2);



// Handle pre-deletion actions

add_action('sentinel_before_data_deletion', function($user_id) {

    // Perform any necessary actions before data deletion

    // e.g., notify administrators, log the request

});



// Handle post-deletion actions

add_action('sentinel_after_data_deletion', function($user_id) {

    // Perform any necessary actions after data deletion

    // e.g., send confirmation email, update external systems

});

What Gets Deleted

When a user requests data deletion, Sentinel will remove the following data:

Best Practices

Follow these guidelines when implementing data deletion requests:

Supported Integrations

Sentinel automatically detects and provides monitoring templates for the following popular WordPress plugins:

Key Features

How It Works

Sentinel's third-party plugin integrations work seamlessly with your existing plugins:

Overview

WooCommerce Integration provides comprehensive monitoring of your online store activities. Track orders, payments, inventory changes, and customer interactions with automated event logging that requires no additional configuration once enabled.

Order Management

1. Navigate to Sentinel → Event Registry
2. Locate '3rd Party Plugin Integrations' section
3. Click 'Setup WooCommerce Events' button
4. Events are automatically created and enabled
5. Control events directly in Plugin Integrations section
6. Monitor orders in Activity Log

Overview

Contact Form 7 Integration provides comprehensive monitoring of your contact form activities. Track successful submissions, identify failed submissions, and analyze user engagement with detailed event logging that captures form metadata and submission details.

Tracked Events

The Contact Form 7 integration automatically monitors the following events:

Overview

WPForms Integration provides comprehensive monitoring of your WPForms activities. Track form submissions, payment completions, and user interactions with detailed event logging that captures form metadata, field information, and payment details.

Tracked Events

The WPForms integration automatically monitors the following events:

Overview

Gravity Forms Integration provides comprehensive monitoring of your Gravity Forms activities. Track form submissions, payment completions, and user interactions with detailed event logging that captures form metadata and submission details.

Tracked Events

The Gravity Forms integration automatically monitors the following events:

Overview

Yoast SEO Integration provides comprehensive monitoring of your SEO optimization activities. Track meta field updates, SEO score changes, schema markup modifications, and bulk SEO operations with detailed event logging that captures specific field changes, score improvements, and optimization patterns.

SEO Event Tracking

The Yoast SEO integration automatically monitors the following SEO activities:

Smart Detection Features

The Yoast SEO integration includes intelligent detection capabilities:

Setup Instructions

Setting up Yoast SEO monitoring is automatic once both plugins are active:

Initial Setup

Setting up third-party plugin integrations is a straightforward process that requires minimal configuration:

Overview

File monitoring tracks changes to critical WordPress files using MD5 hash verification. When files are modified, Sentinel logs the event with detailed information about the change.

How It Works

Sentinel's file monitoring system works through a simple but effective process:

Setup & Configuration

Configure file monitoring through the Sentinel settings page:

1. Navigate to Sentinel → Settings
2. Go to 'Privacy & Security' tab
3. Enable 'File Monitoring'
4. Configure monitoring frequency (hourly/daily/weekly)
5. Enable 'Exclude Log Files' (recommended)
6. Set alert threshold (default: 10 bytes)
7. Add custom exclusion patterns if needed
8. Set up theme/plugin monitoring (Sentinel+)
9. Save settings

Monitored Files

Sentinel monitors different types of files based on your configuration:

Custom File Path Examples

# Theme files
wp-content/themes/your-theme/functions.php
wp-content/themes/your-theme/style.css

# Plugin files
wp-content/plugins/important-plugin/plugin.php

# Server configs
/etc/apache2/sites-available/your-site.conf
/var/www/html/.htaccess

# Custom files
wp-content/uploads/critical-config.json

Understanding Alerts

When file changes are detected, Sentinel logs detailed information about the modification:

Event Details

Change Summary Examples

wp-config.php was modified (+156 bytes) - WordPress configuration file had moderate additions

.htaccess was modified (-23 bytes) - Server configuration file had minor deletions

custom-config.php was modified (same size - content changed) - Critical system file was modified (same size - content changed)

Best Practices

Follow these recommendations for effective file monitoring:

Troubleshooting

Common issues and solutions for file monitoring:

Enhanced Diff Viewer (Sentinel+)

Sentinel+ includes an advanced diff viewer that shows exactly what changed in your files - similar to GitHub's diff view. This premium feature goes beyond basic hash detection to provide detailed line-by-line comparisons.

How It Works

When a file is modified, Sentinel+ automatically:

1. Creates baseline: Stores the original file content when first detected
2. Generates diff: Compares current content with stored baseline
3. Stores history: Maintains up to 10 recent changes per file
4. Shows changes: Displays unified diff format with syntax highlighting

Using the Diff Viewer

The diff viewer appears in both the dashboard activity feed and the full logs view:

Best Practices

• Regular Reviews: Check file changes weekly, especially on production sites
• Investigate Unknowns: Any unexpected changes should be investigated immediately
• Document Changes: Keep notes about legitimate changes for future reference
• Monitor Critical Files: Pay special attention to wp-config.php, .htaccess, and theme files
• Backup Before Changes: Use the diff viewer to verify changes before accepting them

Notification Types

Sentinel offers three types of notifications:

• Real-time Alerts: Instant email notifications for critical security events
• Daily Digests: Comprehensive daily summaries of site activity and errors
• Weekly Reports: Detailed analytics including health reports and security trends

Setting Up Real-time Alerts

Configure instant notifications for critical events. Navigate to Sentinel → Settings → Notifications to access these settings.

Alert Types & Triggers

Choose which events trigger immediate notifications:

Fine-tuning Options

Additional filters to control when alerts are sent:

• Category Filters: Select specific event categories (Authentication, Content, System, Error, Security)
• Priority Filters: Choose priority levels (High, Medium, Low)
• Per-event Control: Disable individual events in Sentinel → Event Registry (affects both logging and alerts)

Email Recipients

Configure who receives alert notifications in Sentinel → Settings → Notifications.

Daily Digest Reports

Aggregated reports sent daily at ~9:00 AM site time via WP-Cron:

Weekly Digest Reports

Comprehensive weekly reports sent on Mondays at ~9:00 AM site time:

Recommended Starter Configuration

Production-ready configuration for development and production environments:

Data Export

Pull activity records into different formats for review, reporting or regulatory compliance. Whether you're analysing patterns or preparing audits, there's a format to suit your needs.

Supported Formats

• CSV: Great for spreadsheet programs such as Excel or Google Sheets
• JSON: Ideal when connecting to external systems or APIs
• XML: Provides compatibility with older or legacy applications

Role-Based Permissions

Control access to Sentinel features based on user roles:

Available Action Hooks

These are the actual hooks provided by Sentinel that you can use to extend functionality.

// Triggered after any event is successfully logged
// Parameters: $event_key (string), $event_data (array), $user_id (int)
add_action('sentinel_event_logged', 'my_event_handler', 10, 3);

function my_event_handler($event_key, $event_data, $user_id) {
    // Send critical security events to Slack
    $critical_events = ['failed_login_attempt', 'user_role_changed', 'plugin_activated'];
    if (in_array($event_key, $critical_events)) {
        $user = get_user_by('ID', $user_id);
        $username = $user ? $user->display_name : 'System';

        wp_remote_post('https://hooks.slack.com/your-webhook-url', [
            'body' => json_encode([
                'text' => sprintf('🚨 Security Event: %s by %s', $event_key, $username),
                'attachments' => [
                    [
                        'color' => 'danger',
                        'fields' => [
                            ['title' => 'Event', 'value' => $event_key, 'short' => true],
                            ['title' => 'User', 'value' => $username, 'short' => true],
                            ['title' => 'Data', 'value' => json_encode($event_data, JSON_PRETTY_PRINT)]
                        ]
                    ]
                ]
            ])
        ]);
    }

    // Log high-priority events to external monitoring service
    $priority_events = ['maintenance_mode_enabled', 'security_incident_opened', 'core_file_modified'];
    if (in_array($event_key, $priority_events)) {
        wp_remote_post('https://monitoring-service.com/api/events', [
            'headers' => [
                'Content-Type' => 'application/json',
                'Authorization' => 'Bearer ' . get_option('monitoring_api_key')
            ],
            'body' => json_encode([
                'source' => 'WordPress-Sentinel',
                'site' => get_site_url(),
                'event_type' => $event_key,
                'user_id' => $user_id,
                'data' => $event_data,
                'timestamp' => current_time('mysql')
            ])
        ]);
    }
}

// Triggered when a new event type is registered with Sentinel
// Parameters: $event_key (string), $config (array)
add_action('sentinel_event_registered', 'handle_new_event_registration', 10, 2);

function handle_new_event_registration($event_key, $config) {
    // Log when new custom events are registered
    error_log(sprintf(
        'New Sentinel event registered: %s (Category: %s, Priority: %s)',
        $event_key,
        $config['category'] ?? 'unknown',
        $config['priority'] ?? 'medium'
    ));

    // Automatically enable high-priority security events
    if (isset($config['category']) && $config['category'] === 'security') {
        if (isset($config['priority']) && in_array($config['priority'], ['high', 'critical'])) {
            // Ensure this security event is not disabled
            $disabled_events = get_option('sentinel_disabled_events', []);
            if (in_array($event_key, $disabled_events)) {
                $disabled_events = array_diff($disabled_events, [$event_key]);
                update_option('sentinel_disabled_events', $disabled_events);
            }
        }
    }

    // Notify administrators about new business-critical events
    if (isset($config['category']) && $config['category'] === 'business') {
        $admin_email = get_option('admin_email');
        wp_mail(
            $admin_email,
            'New Business Event Registered in Sentinel',
            sprintf(
                'A new business event has been registered: %s\n\nDescription: %s\n\nThis event is now being monitored.',
                $event_key,
                $config['description'] ?? 'No description provided'
            )
        );
    }
}

// Triggered when a security incident notification is sent
// Parameters: $notification_data (array) containing incident details
add_action('sentinel_security_incident_notification', 'handle_security_incidents', 10, 1);

function handle_security_incidents($notification_data) {
    $incident_id = $notification_data['incident_id'] ?? 'unknown';
    $event = $notification_data['event'] ?? [];

    // Send immediate SMS alert for critical security incidents
    if (isset($event['priority']) && $event['priority'] === 'critical') {
        // Using a service like Twilio
        wp_remote_post('https://api.twilio.com/2010-04-01/Accounts/YOUR_ACCOUNT_SID/Messages.json', [
            'headers' => [
                'Authorization' => 'Basic ' . base64_encode('YOUR_ACCOUNT_SID:YOUR_AUTH_TOKEN')
            ],
            'body' => [
                'From' => '+1234567890',
                'To' => '+1987654321',
                'Body' => sprintf(
                    'CRITICAL SECURITY ALERT: Incident #%s detected on %s. Event: %s',
                    $incident_id,
                    get_site_url(),
                    $event['event_key'] ?? 'Unknown'
                )
            ]
        ]);
    }

    // Log to external security information and event management (SIEM) system
    wp_remote_post('https://your-siem-system.com/api/incidents', [
        'headers' => [
            'Content-Type' => 'application/json',
            'X-API-Key' => get_option('siem_api_key')
        ],
        'body' => json_encode([
            'source' => 'WordPress-Sentinel',
            'incident_id' => $incident_id,
            'site' => get_site_url(),
            'severity' => $event['priority'] ?? 'medium',
            'event_details' => $event,
            'timestamp' => current_time('c')
        ])
    ]);

    // Create ticket in support system for high-priority incidents
    if (in_array($event['priority'] ?? 'medium', ['high', 'critical'])) {
        wp_remote_post('https://support-system.com/api/tickets', [
            'headers' => [
                'Authorization' => 'Bearer ' . get_option('support_api_token'),
                'Content-Type' => 'application/json'
            ],
            'body' => json_encode([
                'title' => sprintf('Security Incident #%s - %s', $incident_id, $event['event_key'] ?? 'Unknown'),
                'description' => sprintf(
                    'Security incident detected by Sentinel monitoring system.\n\nIncident ID: %s\nSite: %s\nEvent: %s\nPriority: %s\n\nDetails: %s',
                    $incident_id,
                    get_site_url(),
                    $event['event_key'] ?? 'Unknown',
                    $event['priority'] ?? 'medium',
                    json_encode($event, JSON_PRETTY_PRINT)
                ),
                'priority' => $event['priority'] ?? 'medium',
                'category' => 'security'
            ])
        ]);
    }
}

Filter Hooks

Currently, Sentinel does not provide any filter hooks for modifying data or behavior. All extension points are provided through action hooks shown above.

Core Functions

Essential functions for integrating with Sentinel.

// Log an event

sentinel_log_event($event_type, $message, $user_id = null, $metadata = []);



// Get recent events

$events = sentinel_get_recent_events($limit = 10);



// Check if event type is enabled

$enabled = sentinel_is_event_enabled($event_type);

Main Classes

Core classes for advanced integration.

// Initialize logger

$logger = new Sentinel_Logger();



// Log an event

$logger->log($event_type, $message, $user_id, $metadata);



// Get events with filters

$events = $logger->get_events([

    'user_id' => 1,

    'event_type' => 'login',

    'date_from' => '2024-01-01'

]);

Overview

Sentinel+ includes advanced features that enhance your WordPress security monitoring capabilities:

Purchase Process

Getting Sentinel+ is quick and easy:

License Activation

Activate your Sentinel+ license to unlock premium features:

// 1. Navigate to Sentinel Settings in WordPress Admin

// Go to: WordPress Admin → Sentinel → Settings

// 2. Enter your license key in the License Key field

// Format: SEN-XXXX-XXXX-XXXX-XXXX

// 3. Click "Activate License"

// 4. Verify activation status shows "Active"

Verification

Confirm your Sentinel+ activation is working correctly:

Troubleshooting

Common issues and solutions for Sentinel+ activation:

API Configuration

Enable and configure REST API access through the WordPress admin interface.

API Key Authentication

Sentinel provides secure API key authentication for REST API access. Generate API keys through the WordPress admin to provide token-based access without requiring WordPress user accounts.

Generating API Keys

Authentication Methods

Include your API key in requests using either method:

JavaScript Example

Base URL & Namespace

All API endpoints use the following base structure:

https://yoursite.com/wp-json/sentinel-plugin/v1/

API Namespace: sentinel-plugin/v1

Response Format: JSON

Available Endpoints

The following REST API endpoints are currently available:

GET /logs

Retrieve activity logs with optional filtering and pagination support.

curl -X GET 'https://yoursite.com/wp-json/sentinel-plugin/v1/logs'

Query Parameters:

• limit (integer) - Number of logs to return. Default: 50, Max: 1000
• offset (integer) - Number of logs to skip. Default: 0
• event_key (string) - Filter by specific event type
• priority (string) - Filter by priority level (low, medium, high, critical)
• user_id (integer) - Filter by specific user ID

curl -X GET 'https://yoursite.com/wp-json/sentinel-plugin/v1/logs?event_key=user_login&limit=25&priority=high'

{
  "logs": [
    {
      "id": 123,
      "event_key": "user_login",
      "category": "authentication",
      "priority": "medium",
      "user_id": 1,
      "ip_address": "192.168.1.100",
      "url": "/wp-admin/",
      "data": {
        "username": "admin",
        "success": true
      },
      "created_at": "2024-01-15 10:30:45",
      "user": {
        "username": "admin",
        "display_name": "Administrator"
      }
    }
  ],
  "pagination": {
    "total": 1250,
    "limit": 50,
    "offset": 0,
    "pages": 25
  }
}

GET /stats

Retrieve summary statistics and activity breakdowns.

curl -X GET 'https://yoursite.com/wp-json/sentinel-plugin/v1/stats'

{
  "summary": {
    "total_logs": 5420,
    "today_logs": 127,
    "active_users_today": 8
  },
  "categories": [
    {
      "name": "authentication",
      "count": 1245
    },
    {
      "name": "content",
      "count": 892
    }
  ],
  "priorities": [
    {
      "name": "medium",
      "count": 3210
    },
    {
      "name": "low",
      "count": 1890
    }
  ]
}

GET /events/types

List all registered event types with their configuration details.

curl -X GET 'https://yoursite.com/wp-json/sentinel-plugin/v1/events/types'

{
  "event_types": [
    {
      "key": "user_login",
      "label": "User Login",
      "category": "authentication",
      "priority": "medium",
      "description": "User successfully logs into the system"
    },
    {
      "key": "woo_new_order",
      "label": "WooCommerce New Order",
      "category": "ecommerce",
      "priority": "high",
      "description": "New order placed by customer"
    }
  ],
  "total": 24
}

Error Responses

Standard HTTP error responses and error codes.

{
  "code": "rest_forbidden",
  "message": "API access is disabled.",
  "data": {
    "status": 403
  }
}

Integration Examples

Real-world examples of integrating with the Sentinel REST API.

// Monitor login failures in real-time
const fetch = require('node-fetch');

async function checkLoginFailures() {
  try {
    const response = await fetch('https://yoursite.com/wp-json/sentinel-plugin/v1/logs?event_key=failed_login&limit=10');
    const data = await response.json();

    if (data.logs.length > 0) {
      console.log(`${data.logs.length} recent login failures detected`);

      data.logs.forEach(log => {
        console.log(`Failed login from ${log.ip_address} at ${log.created_at}`);
      });
    }
  } catch (error) {
    console.error('API request failed:', error);
  }
}

// Check every 5 minutes
setInterval(checkLoginFailures, 5 * 60 * 1000);

<?php
// External monitoring script
function my_site_activity_summary($site_url) {
    $api_url = rtrim($site_url, '/') . '/wp-json/sentinel-plugin/v1/stats';

    $response = wp_remote_get($api_url);

    if (is_wp_error($response)) {
        error_log('Sentinel API error: ' . $response->get_error_message());
        return false;
    }

    $data = json_decode(wp_remote_retrieve_body($response), true);

    if (isset($data['summary'])) {
        return [
            'total_logs' => $data['summary']['total_logs'],
            'today_activity' => $data['summary']['today_logs'],
            'active_users' => $data['summary']['active_users_today']
        ];
    }

    return false;
}

// Usage
$summary = my_site_activity_summary('https://yoursite.com');
if ($summary) {
    echo 'Today: ' . $summary['today_activity'] . ' activities by ' . $summary['active_users'] . ' users';
}
?>

import requests
import json

class SentinelAPI:
    def __init__(self, base_url):
        self.base_url = base_url.rstrip('/') + '/wp-json/sentinel-plugin/v1'

    def get_logs(self, **filters):
        '''Get activity logs with optional filters'''
        response = requests.get(f'{self.base_url}/logs', params=filters)
        response.raise_for_status()
        return response.json()

    def get_stats(self):
        '''Get activity statistics'''
        response = requests.get(f'{self.base_url}/stats')
        response.raise_for_status()
        return response.json()

    def get_security_events(self, limit=50):
        '''Get security-related events'''
        return self.get_logs(
            event_key='failed_login,suspicious_activity',
            priority='high,critical',
            limit=limit
        )

# Usage
api = SentinelAPI('https://yoursite.com')

# Get today's failed logins
failed_logins = api.get_logs(event_key='failed_login', limit=10)
print(f'Recent failed logins: {len(failed_logins["logs"])}')

# Get site statistics
stats = api.get_stats()
print(f'Total logs: {stats["summary"]["total_logs"]}')

Rate Limiting & Best Practices

Guidelines for responsible API usage and performance optimization.

Recommended Practices:

• Pagination: Use limit and offset parameters for large datasets
• Filtering: Apply specific filters to reduce response sizes
• Caching: Cache responses locally when appropriate
• Error Handling: Implement proper error handling and retry logic
• Monitoring: Monitor your API usage to avoid overwhelming the server

Troubleshooting FAQs

Common issues and their solutions.

Overview

Custom Events bridge the gap between WordPress core monitoring and your specific business needs. While 3rd Party Plugin Integrations handle popular plugins like WooCommerce automatically, Custom Events let you create monitoring for unique business logic, specialized workflows, and unsupported plugins.

Creating Custom Events

For unique business requirements or unsupported plugins, create custom events manually through the admin interface.

// Log a custom event
sentinel_log_event('newsletter_signup', [
    'email' => $user_email,
    'source' => 'homepage_widget',
    'user_id' => get_current_user_id()
]);

// Log with custom user context
sentinel_log_event('form_abandoned', [
    'form_id' => $form_id,
    'completion_percentage' => 75,
    'time_spent' => 120
], $user_id);

Developer Hooks & Filters

Extend custom event functionality with WordPress hooks and filters.

// Hook into when events are logged
add_action('sentinel_event_logged', 'my_custom_event_handler', 10, 3);

function my_custom_event_handler($event_key, $event_data, $user_id) {
    // Custom logic when any event is logged
    if ($event_key === 'user_login') {
        // Do something special for login events
        update_user_meta($user_id, 'last_login_tracked', current_time('mysql'));
    }
}

Parameters:

• $event_key (string) - The event key that was logged
• $event_data (array) - Additional data associated with the event
• $user_id (int) - ID of the user who triggered the event

// Hook into event registration
add_action('sentinel_event_registered', 'my_event_registration_handler', 10, 2);

function my_event_registration_handler($event_key, $config) {
    // React to new events being registered
    if ($config['category'] === 'security') {
        // Enable special monitoring for security events
        update_option('my_security_monitoring_' . $event_key, true);
    }
}

Parameters:

• $event_key (string) - The event key being registered
• $config (array) - Configuration array for the event

Advanced Functions

Programmatic functions for custom event management and integration.

// Register a basic custom event
sentinel_register_event('newsletter_signup', [
    'category' => 'marketing',
    'priority' => 'medium',
    'description' => 'User signed up for newsletter'
]);

// Register a security event
sentinel_register_event('suspicious_activity', [
    'category' => 'security',
    'priority' => 'high',
    'description' => 'Suspicious user behavior detected',
    'data_fields' => ['ip_address', 'user_agent', 'risk_score']
]);

// Register an ecommerce event
sentinel_register_event('cart_abandoned', [
    'category' => 'ecommerce',
    'priority' => 'low',
    'description' => 'Shopping cart was abandoned',
    'data_fields' => ['cart_value', 'items_count', 'user_id']
]);

Configuration Options:

• category (string) - Event category: authentication, content, system, security, user, admin, general, audit
• priority (string) - Priority level: low, medium, high, critical
• description (string) - Human-readable description
• data_fields (array) - Expected data field names
• enabled (bool) - Whether event is enabled. Default: true

Plugin & Theme Integration

Real-world examples of integrating custom events into your plugins and themes.

// In your plugin's main file
class My_Plugin {

    public function __construct() {
        // Register custom events on plugin activation
        register_activation_hook(__FILE__, [$this, 'setup_sentinel_events']);

        // Hook into your plugin's key actions
        add_action('my_plugin_user_action', [$this, 'log_user_action']);
        add_action('my_plugin_error', [$this, 'log_plugin_error']);
    }

    public function setup_sentinel_events() {
        if (!function_exists('sentinel_register_event')) {
            return; // Sentinel not available
        }

        // Register plugin-specific events
        sentinel_register_event('my_plugin_action', [
            'category' => 'user',
            'priority' => 'medium',
            'description' => 'User performed action in My Plugin'
        ]);

        sentinel_register_event('my_plugin_error', [
            'category' => 'system',
            'priority' => 'high',
            'description' => 'Error occurred in My Plugin'
        ]);
    }

    public function log_user_action($action_data) {
        if (function_exists('sentinel_log_event')) {
            sentinel_log_event('my_plugin_action', $action_data);
        }
    }

    public function log_plugin_error($error) {
        if (function_exists('sentinel_log_event')) {
            sentinel_log_event('my_plugin_error', [
                'error_message' => $error->get_error_message(),
                'error_code' => $error->get_error_code()
            ]);
        }
    }
}

// In your theme's functions.php
function my_theme_init() {
    // Register theme-specific events
    if (function_exists('sentinel_register_event')) {
        sentinel_register_event('theme_customizer_changed', [
            'category' => 'content',
            'priority' => 'low',
            'description' => 'Theme customizer settings modified'
        ]);
    }
}
add_action('init', 'my_theme_init');

// Log theme-specific events
function log_customizer_change($setting, $value) {
    if (function_exists('sentinel_log_event')) {
        sentinel_log_event('theme_customizer_changed', [
            'setting' => $setting,
            'new_value' => $value,
            'changed_by' => get_current_user_id()
        ]);
    }
}

// Hook into WordPress customizer
add_action('customize_save_after', function($customizer) {
    log_customizer_change('theme_options', 'bulk_update');
});