Designing audit logs for enterprise WordPress setups tracking internal user modifications to event ticket registers

Core Requirements for Enterprise Audit Logging in WordPress

When designing audit logs for enterprise WordPress installations, particularly those managing sensitive data like event ticket registers, the primary concerns are immutability, granular detail, and efficient retrieval. For internal user modifications, we need to capture not just *what* changed, but *who* changed it, *when*, and the specific values before and after the modification. This is critical for compliance, security incident investigation, and debugging complex data interactions.

A robust audit log system for WordPress should address the following:

• Event Tracking: Log all CRUD (Create, Read, Update, Delete) operations on critical data entities, specifically custom post types or database tables representing event tickets.
• User Attribution: Clearly link each logged event to the specific authenticated user who performed the action.
• Timestamping: Record the exact date and time of the action with sufficient precision (e.g., milliseconds if necessary).
• Data Delta: Store the state of the modified data before and after the change. This is often the most challenging aspect, especially for complex data structures.
• Contextual Information: Include relevant context, such as the IP address of the user, the browser user agent, and the specific WordPress action hook that triggered the change.
• Storage Strategy: Determine an appropriate storage mechanism that balances performance, scalability, and data integrity. Direct database logging can become a bottleneck; dedicated logging services or structured file logging are often preferred.
• Access Control: Implement strict access controls for viewing audit logs, ensuring only authorized personnel can access this sensitive information.

Implementing a Custom Audit Log Plugin Architecture

For enterprise-grade solutions, relying solely on third-party plugins can introduce dependencies and potential security risks. Developing a custom plugin offers maximum control and tailorability. The architecture should be modular, leveraging WordPress hooks and potentially external services.

We’ll focus on logging modifications to a hypothetical custom post type, `event_ticket`. The core of our logging mechanism will be a service class that handles the actual writing of log entries.

The Audit Log Service Class (PHP)

This class will encapsulate the logic for creating and storing audit log entries. We’ll use a simple database table for demonstration, but in a production environment, consider a dedicated logging system (e.g., ELK stack, Splunk) or structured JSON files with rotation.

First, let’s define the database table structure. This would typically be handled by a plugin’s activation hook.

Database Table Schema

A table named `wp_audit_logs` would be suitable:

CREATE TABLE wp_audit_logs (
    log_id BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
    timestamp DATETIME NOT NULL DEFAULT '0000-00-00 00:00:00',
    user_id BIGINT(20) UNSIGNED NULL,
    username VARCHAR(255) NOT NULL DEFAULT '',
    action VARCHAR(100) NOT NULL DEFAULT '',
    object_type VARCHAR(100) NOT NULL DEFAULT '',
    object_id BIGINT(20) UNSIGNED NOT NULL,
    old_value LONGTEXT NULL,
    new_value LONGTEXT NULL,
    ip_address VARCHAR(100) NOT NULL DEFAULT '',
    context TEXT NULL,
    PRIMARY KEY (log_id),
    KEY idx_user_id (user_id),
    KEY idx_object (object_type, object_id),
    KEY idx_timestamp (timestamp)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Audit Log Service Implementation

namespace Antigravity\AuditLog;

class AuditLogService {
    private $table_name;

    public function __construct() {
        global $wpdb;
        $this->table_name = $wpdb->prefix . 'audit_logs';
    }

    /**
     * Logs an audit event.
     *
     * @param array $log_data Associative array of log data.
     *                        Required keys: 'action', 'object_type', 'object_id'.
     *                        Optional keys: 'user_id', 'username', 'old_value', 'new_value', 'ip_address', 'context'.
     * @return int|false The ID of the inserted log entry, or false on failure.
     */
    public function log( array $log_data ) {
        global $wpdb;

        if ( ! isset( $log_data['action'] ) || ! isset( $log_data['object_type'] ) || ! isset( $log_data['object_id'] ) ) {
            // Log an internal error or throw an exception if critical data is missing.
            error_log( 'AuditLogService: Missing critical data for logging.' );
            return false;
        }

        $current_user = wp_get_current_user();
        $user_id = $current_user->ID ?? 0;
        $username = $current_user->user_login ?? 'Guest';

        $data = array(
            'timestamp'   => current_time( 'mysql' ),
            'user_id'     => $user_id,
            'username'    => $username,
            'action'      => sanitize_text_field( $log_data['action'] ),
            'object_type' => sanitize_key( $log_data['object_type'] ),
            'object_id'   => absint( $log_data['object_id'] ),
            'old_value'   => isset( $log_data['old_value'] ) ? wp_json_encode( $log_data['old_value'] ) : null,
            'new_value'   => isset( $log_data['new_value'] ) ? wp_json_encode( $log_data['new_value'] ) : null,
            'ip_address'  => sanitize_text_field( $log_data['ip_address'] ?? $this->get_user_ip() ),
            'context'     => isset( $log_data['context'] ) ? wp_json_encode( $log_data['context'] ) : null,
        );

        $format = array(
            '%s', // timestamp
            '%d', // user_id
            '%s', // username
            '%s', // action
            '%s', // object_type
            '%d', // object_id
            '%s', // old_value (JSON encoded string)
            '%s', // new_value (JSON encoded string)
            '%s', // ip_address
            '%s', // context (JSON encoded string)
        );

        $result = $wpdb->insert( $this->table_name, $data, $format );

        if ( $result === false ) {
            error_log( 'AuditLogService: Failed to insert log entry. WPDB Error: ' . $wpdb->last_error );
            return false;
        }

        return $wpdb->insert_id;
    }

    /**
     * Retrieves the user's IP address.
     * Handles various server configurations and proxies.
     *
     * @return string
     */
    private function get_user_ip() {
        $ip = '';
        if ( ! empty( $_SERVER['HTTP_CLIENT_IP'] ) ) {
            $ip = $_SERVER['HTTP_CLIENT_IP'];
        } elseif ( ! empty( $_SERVER['HTTP_X_FORWARDED_FOR'] ) ) {
            $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
        } elseif ( ! empty( $_SERVER['REMOTE_ADDR'] ) ) {
            $ip = $_SERVER['REMOTE_ADDR'];
        }

        // Handle multiple IPs in X-Forwarded-For
        if ( strpos( $ip, ',' ) !== false ) {
            $ips = explode( ',', $ip );
            $ip = trim( $ips[0] );
        }

        return filter_var( $ip, FILTER_VALIDATE_IP ) ? $ip : '0.0.0.0';
    }

    /**
     * Retrieves log entries.
     *
     * @param array $args Query arguments.
     * @return array
     */
    public function get_logs( array $args = array() ) {
        global $wpdb;
        $query_args = wp_parse_args( $args, array(
            'user_id'     => null,
            'object_type' => null,
            'object_id'   => null,
            'action'      => null,
            'date_from'   => null,
            'date_to'     => null,
            'limit'       => 50,
            'offset'      => 0,
            'orderby'     => 'timestamp',
            'order'       => 'DESC',
        ) );

        $where_clauses = array();
        $where_values = array();

        if ( $query_args['user_id'] !== null ) {
            $where_clauses[] = 'user_id = %d';
            $where_values[] = absint( $query_args['user_id'] );
        }
        if ( $query_args['object_type'] !== null ) {
            $where_clauses[] = 'object_type = %s';
            $where_values[] = sanitize_key( $query_args['object_type'] );
        }
        if ( $query_args['object_id'] !== null ) {
            $where_clauses[] = 'object_id = %d';
            $where_values[] = absint( $query_args['object_id'] );
        }
        if ( $query_args['action'] !== null ) {
            $where_clauses[] = 'action = %s';
            $where_values[] = sanitize_text_field( $query_args['action'] );
        }
        if ( $query_args['date_from'] !== null ) {
            $where_clauses[] = 'timestamp >= %s';
            $where_values[] = sanitize_text_field( $query_args['date_from'] );
        }
        if ( $query_args['date_to'] !== null ) {
            $where_clauses[] = 'timestamp <= %s';
            $where_values[] = sanitize_text_field( $query_args['date_to'] );
        }

        $where_sql = '';
        if ( ! empty( $where_clauses ) ) {
            $where_sql = 'WHERE ' . implode( ' AND ', $where_clauses );
        }

        $orderby = sanitize_sql_orderby( $query_args['orderby'] );
        $order = strtoupper( $query_args['order'] );
        if ( ! in_array( $order, array( 'ASC', 'DESC' ) ) ) {
            $order = 'DESC';
        }

        $limit = absint( $query_args['limit'] );
        $offset = absint( $query_args['offset'] );

        $sql = "SELECT * FROM {$this->table_name} {$where_sql} ORDER BY {$orderby} {$order} LIMIT {$limit} OFFSET {$offset}";

        $query_values = array_merge( $where_values, array(), array() ); // Placeholder for potential GROUP BY, etc.

        $results = $wpdb->get_results( $wpdb->prepare( $sql, $query_values ) );

        if ( $wpdb->last_error ) {
            error_log( 'AuditLogService: Failed to retrieve logs. WPDB Error: ' . $wpdb->last_error );
            return array();
        }

        // Decode JSON fields
        foreach ( $results as $row ) {
            $row->old_value = $row->old_value ? json_decode( $row->old_value, true ) : null;
            $row->new_value = $row->new_value ? json_decode( $row->new_value, true ) : null;
            $row->context = $row->context ? json_decode( $row->context, true ) : null;
        }

        return $results;
    }
}

Integrating with WordPress Actions

We need to hook into WordPress actions that modify our `event_ticket` post type. This typically involves the `save_post` hook, but we must be careful to avoid infinite loops and to only log relevant changes.

A common pattern is to use a meta box or a custom save function for the post type. For simplicity, we’ll demonstrate hooking into `save_post` for the `event_ticket` post type.

Hooking into `save_post`

add_action( 'save_post_event_ticket', 'antigravity_log_event_ticket_changes', 10, 3 );

function antigravity_log_event_ticket_changes( $post_id, $post, $update ) {
    // Prevent infinite loops.
    if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
        return;
    }

    // Check user permissions.
    if ( ! current_user_can( 'edit_post', $post_id ) ) {
        return;
    }

    // If this is a revision, do nothing.
    if ( wp_is_post_revision( $post_id ) ) {
        return;
    }

    // If this is a new post, log creation.
    if ( ! $update ) {
        $audit_log_service = new Antigravity\AuditLog\AuditLogService();
        $audit_log_service->log( array(
            'action'      => 'created',
            'object_type' => 'event_ticket',
            'object_id'   => $post_id,
            'new_value'   => get_post_meta( $post_id ), // Or specific fields
            'context'     => array( 'post_title' => $post->post_title ),
        ) );
        return;
    }

    // Log updates.
    $audit_log_service = new Antigravity\AuditLog\AuditLogService();
    $old_post_data = get_post( $post_id, ARRAY_A ); // Get previous version of post data
    $new_post_data = $post->to_array(); // Current post object

    // Compare relevant fields.
    $changed_fields = array();
    $old_values = array();
    $new_values = array();

    $fields_to_track = array( 'post_title', 'post_content', 'post_status' ); // Add custom meta keys here

    foreach ( $fields_to_track as $field ) {
        if ( isset( $old_post_data[$field] ) && $old_post_data[$field] !== $new_post_data[$field] ) {
            $changed_fields[] = $field;
            $old_values[$field] = $old_post_data[$field];
            $new_values[$field] = $new_post_data[$field];
        }
    }

    // Log custom meta fields (example: 'event_date', 'ticket_price')
    $meta_keys_to_track = array( '_event_date', '_ticket_price', '_event_location' );
    foreach ( $meta_keys_to_track as $meta_key ) {
        $old_meta = get_post_meta( $post_id, $meta_key, true );
        $new_meta = $new_post_data[$meta_key] ?? null; // Assuming meta is directly accessible or fetched

        // Need to fetch meta for the *old* post version if available.
        // This is tricky with save_post. A better approach is to use `wp_get_post_revisions` or store old meta before saving.
        // For simplicity here, we'll assume we can get the old meta. A more robust solution would involve storing it temporarily.

        // A more reliable way to get old meta:
        $revisions = wp_get_post_revisions( $post_id );
        $old_meta_for_comparison = null;
        if ( ! empty( $revisions ) ) {
            $latest_revision_id = $revisions[0]->ID;
            $old_meta_for_comparison = get_post_meta( $latest_revision_id, $meta_key, true );
        }

        if ( $old_meta_for_comparison !== $new_meta ) {
            $changed_fields[] = $meta_key;
            $old_values[$meta_key] = $old_meta_for_comparison;
            $new_values[$meta_key] = $new_meta;
        }
    }


    if ( ! empty( $changed_fields ) ) {
        $audit_log_service->log( array(
            'action'      => 'updated',
            'object_type' => 'event_ticket',
            'object_id'   => $post_id,
            'old_value'   => $old_values,
            'new_value'   => $new_values,
            'context'     => array(
                'post_title' => $post->post_title,
                'changed'    => $changed_fields,
            ),
        ) );
    }
}

Important Considerations for `save_post`:**

add_action( 'delete_post', 'antigravity_log_event_ticket_deletion', 10, 1 );

function antigravity_log_event_ticket_deletion( $post_id ) {
    // Ensure it's our post type
    $post = get_post( $post_id );
    if ( ! $post || $post->post_type !== 'event_ticket' ) {
        return;
    }

    // Check user permissions (though this hook fires late, it's good practice)
    if ( ! current_user_can( 'delete_post', $post_id ) ) {
        return;
    }

    // Get data *before* deletion. This is tricky.
    // The best approach is to use a filter on `wp_delete_post` or a transient.
    // For simplicity, we'll try to get the data if it's still available in revisions or cache.
    // A more robust solution would involve storing the post data in a temporary location
    // *before* the delete action is fully processed.

    // Attempt to retrieve data from revisions if available
    $post_data_for_log = null;
    $revisions = wp_get_post_revisions( $post_id );
    if ( ! empty( $revisions ) ) {
        $latest_revision = $revisions[0];
        $post_data_for_log = array(
            'post_title' => $latest_revision->post_title,
            'post_content' => $latest_revision->post_content,
            'post_status' => $latest_revision->post_status,
        );
        // Also retrieve meta from the latest revision
        $meta_keys_to_track = array( '_event_date', '_ticket_price', '_event_location' );
        foreach ( $meta_keys_to_track as $meta_key ) {
            $post_data_for_log[$meta_key] = get_post_meta( $latest_revision->ID, $meta_key, true );
        }
    } else {
        // Fallback: If no revisions, try to get current data before it's gone.
        // This is unreliable.
        $post_data_for_log = array(
            'post_title' => $post->post_title,
            'post_content' => $post->post_content,
            'post_status' => $post->post_status,
        );
        $meta_keys_to_track = array( '_event_date', '_ticket_price', '_event_location' );
        foreach ( $meta_keys_to_track as $meta_key ) {
            $post_data_for_log[$meta_key] = get_post_meta( $post_id, $meta_key, true );
        }
    }


    if ( $post_data_for_log ) {
        $audit_log_service = new Antigravity\AuditLog\AuditLogService();
        $audit_log_service->log( array(
            'action'      => 'deleted',
            'object_type' => 'event_ticket',
            'object_id'   => $post_id,
            'old_value'   => $post_data_for_log, // Store the data that was deleted
            'new_value'   => null,
            'context'     => array( 'original_title' => $post_data_for_log['post_title'] ?? 'N/A' ),
        ) );
    }
}