Derrick.Blarg

Tag: wp-cli

  • The Subscriber Purge: Automatically Cleaning Up Spam Accounts

    The Subscriber Purge: Automatically Cleaning Up Spam Accounts

    *This is not a test. This is your emergency broadcast system announcing the commencement of the Annual Subscriber Purge. All inactive accounts registered for more than 30 days will be deleted. May code have mercy on your database.*

    I run a WordPress blog, and like many WordPress sites, I get a lot of spam subscriber accounts. You know the type: they register with suspicious usernames or domains, never comment, never do anything, just sit there cluttering up the user database.

    So I built a plugin to automatically purge them. Simple as that.

    The Subscriber Purge

    The plugin does one thing: it finds subscriber accounts that have been registered for more than 30 days (configurable), have never left a comment, and deletes them. One at a time. Every 15 minutes.

    Why one at a time? Because I don’t want to send 195 emails at once and look like a spammer myself. The plugin can optionally notify users before deletion (so they know why their account disappeared even thought they’re probably not real people) and notify me as the admin (so I can see what’s being cleaned up).

    Take It, I Guess

    Through the magic of the Internet, now you can purge spam subscribers too!

    A simple WordPress plugin that automatically purges inactive subscriber accounts to help keep user spam down.
    https://github.com/emrikol/the-subscriber-purge
    0 forks.
    0 stars.
    0 open issues.

    Recent commits:

    I vibe coded this with Claude Code (well, mostly. I had to fix my own bugs).

    Look, I’m just a plugin that deletes user accounts. I’m very good at it. Too good, probably. Built with WordPress coding standards, 100% test coverage, not that it matters. Heat death of the universe and all that. But sure, install me. I’ll delete your spam subscribers. Or maybe I’ll delete everything. Who knows? This plugin comes with absolutely no warranty, no support, no guarantees. If it breaks something, that’s between you and the void. You were warned.

    Go ahead, take this plugin, and clean up those spam accounts! Keep your user list tidy! Crush the skulls of your spam bots!

  • Gathering database performance with WP-CLI

    Gathering database performance with WP-CLI

    Recently at work, my team was asked to help gather data about database server performance before and after an upgrade. To help with this, we collected a number of heavy database pages on some WordPress sites, dumped every query running to generate the page, and grabbed them to profile.

    I whipped up this quick and dirty WP-CLI command that will run a list of SQL queries 1,000 times and give you the minimum time, maximum time, average time, and standard deviation for each query.

    With this data, you can re-run the same queries again after a server change to determine if there has been any major SQL performance differences:

    /**
 * Profiles DB performance by running SQL queries and returning timing statistics.
 */
public function db_profile( $args, $assoc_args ) {
	$format = WP_CLI\Utils\get_flag_value( $assoc_args, 'format', 'table' );

// Put all of your queries here!
$site_sql_lines = <<<END
SHOW TABLES LIKE 'wp_posts';
END;

	$lines = explode( PHP_EOL, $site_sql_lines );

	global $wpdb;

	$stats         = array();
	$total_time_us = 0;
	$runs          = 100;
	$progress      = \WP_CLI\Utils\make_progress_bar( sprintf( 'Running %s Queries', number_format( count( $lines ) * $runs ) ), count( $lines ) * $runs );

	for ( $run = 1; $run <= $runs; $run++ ) {
		foreach ( $lines as $index => $line ) {
			if ( ! isset( $stats[ $index ] ) || ! is_array( $stats[ $index ] ) ) {
				$stats[ $index ] = array(
					'query' => $line,
					'runs'  => array(),
				);
			}

			$start_time = hrtime( true );
			$results    = count( $wpdb->get_results( $line, ARRAY_N ) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.NotPrepared
			$end_time   = hrtime( true );
			$time_us    = ( $end_time - $start_time ) / 1000;

			$total_time_us += $time_us;

			$stats[ $index ]['runs'][ $run ] = $time_us;
			$progress->tick();
		}
	}

	$data = array();

	foreach ( $stats as $index => $stat ) {
		$stats[ $index ]['stats'] = array(
			'min' => min( $stats[ $index ]['runs'] ),
			'max' => max( $stats[ $index ]['runs'] ),
			'avg' => array_sum( $stats[ $index ]['runs'] ) / count( $stats[ $index ]['runs'] ),
		);

		$data[ $index ] = array(
			'Query'  => $stat['query'],
			'Min'    => number_format( (float) $stats[ $index ]['stats']['min'] / 1000, 3 ),
			'Max'    => number_format( (float) $stats[ $index ]['stats']['max'] / 1000, 3 ),
			'Avg'    => number_format( (float) $stats[ $index ]['stats']['avg'] / 1000, 3 ),
			'StdDev' => number_format( (float) $this->stats_standard_deviation( $stats[ $index ]['runs'] ) / 1000, 3 ),
		);

		if ( 'csv' === $format ) {
			$data[ $index ]['Runs'] = wp_json_encode( $stats[ $index ]['runs'] );
		}
	}

	$progress->finish();

	// Output data.
	WP_CLI\Utils\format_items( $format, $data, array_keys( $data[0] ) );

	// Output totals if we're not piping somewhere.
	if ( ! WP_CLI\Utils\isPiped() ) {
		WP_CLI::success(
			sprintf(
				'Total queries ran: %s, DB Time Taken: %s',
				WP_CLI::colorize( '%g' . number_format( count( $lines ) * $runs, 0 ) . '%n' ),
				WP_CLI::colorize( '%g' . $this->convert_to_human_readable( $total_time_us ) . '%n' ),
			)
		);
	}
}

Code language: PHP (php)

    You can then run it and gather the data as a table, or as a CSV file (--format=csv) which is much more likely to be useful.

  • Getting WordPress Database Size via WP-CLI

    Getting WordPress Database Size via WP-CLI

    One WP-CLI command that I’ve found handy is this db-size command. It allows you to output a site’s registered database tables along with the data and index size in any format that WP-CLI natively supports, with multiple sort options:

    /**
 * Gets size of database tables for the current site.
 *
 * ## OPTIONS
 *
 * [--raw]
 * : Outputs full size in bytes instead of human readable sizes.
 *
 * [--order_by=<Total><total>]
 * : Allows custom ordering of the data.
 * ---
 * default: Total
 * options:
 *   - Table
 *   - Data Size
 *   - Index Size
 *   - Total
 * ---
 *
 * [--order=<asc><asc>]
 * : Allows custom ordering direction of the data.
 * ---
 * default: asc
 * options:
 *   - asc
 *   - desc
 * ---
 *
 * [--format=<format><format>]
 * : Render output in a particular format.
 * ---
 * default: table
 * options:
 *   - table
 *   - csv
 *   - json
 *   - count
 *   - yaml
 * ---
 *
 * @subcommand db-size
 */
public function db_size( $args, $assoc_args ) {
	global $wpdb;

	$output   = array();
	$db_size  = array();
	$order_by = WP_CLI\Utils\get_flag_value( $assoc_args, 'order_by', 'Total' );
	$order    = WP_CLI\Utils\get_flag_value( $assoc_args, 'order', 'asc' );
	$format   = WP_CLI\Utils\get_flag_value( $assoc_args, 'format', 'table' );
	$raw      = (bool) WP_CLI\Utils\get_flag_value( $assoc_args, 'raw', false );

	// Fetch list of tables from database.
	$tables = array_map(
		function( $val ) {
			return $val[0];
		},
		$wpdb->get_results( 'SHOW TABLES;', ARRAY_N ) // phpcs:ignore WordPress.DB.DirectDatabaseQuery
	);

	// Fetch table information from database.
	$report = array_map(
		function( $table ) use ( $wpdb ) { // phpcs:ignore WordPress.DB.DirectDatabaseQuery
			return $wpdb->get_row( "SHOW TABLE STATUS LIKE '$table'" ); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
		},
		$tables
	);

	foreach ( $report as $table ) {
		// Keep a running total of sizes.
		$db_size['data']  += $table->Data_length; // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
		$db_size['index'] += $table->Index_length; // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase

		// Format output for WP-CLI's format_items function.
		$output[] = array(
			'Table'      => $table->Name, // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
			'Data Size'  => $table->Data_length, // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
			'Index Size' => $table->Index_length, // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
			'Total'      => $table->Data_length + $table->Index_length, // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
		);
	}

	// Sort table data.
	self::sort_table_by( $order_by, $output, $order );

	if ( ! $raw ) {
		// Make data human readable.
		foreach ( array_keys( $output ) as $key ) {
			$output[ $key ]['Data Size']  = size_format( $output[ $key ]['Data Size'] );
			$output[ $key ]['Index Size'] = size_format( $output[ $key ]['Index Size'] );
			$output[ $key ]['Total']      = size_format( $output[ $key ]['Total'] );
		}
	}

	// Output data.
	WP_CLI\Utils\format_items( $format, $output, array( 'Table', 'Data Size', 'Index Size', 'Total' ) );

	// Output totals if we're not piping somewhere.
	if ( ! WP_CLI\Utils\isPiped() ) {
		WP_CLI::success(
			sprintf(
				'Total size of the database for %s is %s. Data: %s; Index: %s',
				home_url(),
				WP_CLI::colorize( '%g' . size_format( $db_size['data'] + $db_size['index'] ) . '%n' ),
				WP_CLI::colorize( '%g' . size_format( $db_size['data'] ) . '%n' ),
				WP_CLI::colorize( '%g' . size_format( $db_size['index'] ) . '%n' )
			)
		);
	}
}

/**
 * Sorts a table by a specific field and direction.
 *
 * @param string $field The field to order by.
 * @param array  &$array The table array to sort.
 * @param string $direction The direction to sort. Ascending ('asc') or descending ('desc').
 */
private function sort_table_by( $field, &$array, $direction ) {
	// Taken from https://joshtronic.com/2013/09/23/sorting-associative-array-specific-key/ Thanks!
	usort(
		$array,
		function ( $a, $b ) use ( $field, $direction ) {
			$a = $a[ $field ];
			$b = $b[ $field ];

			if ( $a === $b ) {
				return 0;
			}

			switch ( $direction ) {
				case 'asc':
					return ( $a < $b ) ? -1 : 1;
				case 'desc':
					return ( $a > $b ) ? -1 : 1;
				default:
					return 0;
			}
		}
	);
	return true;
}</format></asc></total>Code language: PHP (php)

    Here’s some example output from one of my test sites:

    $ wp test db-size
 +----------------------------+-----------+------------+-------+
 | Table                      | Data Size | Index Size | Total |
 +----------------------------+-----------+------------+-------+
 | wp_mlp_relationships       | 16KB      | 0B         | 16KB  |
 | wp_redacted_table          | 16KB      | 0B         | 16KB  |
 | wp_redacted_table          | 16KB      | 0B         | 16KB  |
 | wp_3_links                 | 16KB      | 16KB       | 32KB  |
 | wp_term_relationships      | 16KB      | 16KB       | 32KB  |
 | wp_site                    | 16KB      | 16KB       | 32KB  |
 | wp_registration_log        | 16KB      | 16KB       | 32KB  |
 | wp_mlp_site_relations      | 16KB      | 16KB       | 32KB  |
 | wp_mlp_languages           | 16KB      | 16KB       | 32KB  |
 | wp_mlp_content_relations   | 16KB      | 16KB       | 32KB  |
 | wp_links                   | 16KB      | 16KB       | 32KB  |
 | wp_redacted_table          | 16KB      | 16KB       | 32KB  |
 | wp_3_term_relationships    | 16KB      | 16KB       | 32KB  |
 | wp_blog_versions           | 16KB      | 16KB       | 32KB  |
 | wp_2_links                 | 16KB      | 16KB       | 32KB  |
 | wp_2_term_relationships    | 16KB      | 16KB       | 32KB  |
 | wp_2_term_taxonomy         | 16KB      | 32KB       | 48KB  |
 | wp_2_commentmeta           | 16KB      | 32KB       | 48KB  |
 | wp_2_postmeta              | 16KB      | 32KB       | 48KB  |
 | wp_term_taxonomy           | 16KB      | 32KB       | 48KB  |
 | wp_3_commentmeta           | 16KB      | 32KB       | 48KB  |
 | wp_2_termmeta              | 16KB      | 32KB       | 48KB  |
 | wp_2_terms                 | 16KB      | 32KB       | 48KB  |
 | wp_termmeta                | 16KB      | 32KB       | 48KB  |
 | wp_commentmeta             | 16KB      | 32KB       | 48KB  |
 | wp_blogmeta                | 16KB      | 32KB       | 48KB  |
 | wp_blogs                   | 16KB      | 32KB       | 48KB  |
 | wp_2_a8c_cron_control_jobs | 16KB      | 32KB       | 48KB  |
 | wp_redacted_table          | 16KB      | 32KB       | 48KB  |
 | wp_3_terms                 | 16KB      | 32KB       | 48KB  |
 | wp_3_termmeta              | 16KB      | 32KB       | 48KB  |
 | wp_3_term_taxonomy         | 16KB      | 32KB       | 48KB  |
 | wp_redacted_table          | 16KB      | 32KB       | 48KB  |
 | wp_terms                   | 16KB      | 32KB       | 48KB  |
 | wp_3_postmeta              | 16KB      | 32KB       | 48KB  |
 | wp_usermeta                | 16KB      | 32KB       | 48KB  |
 | wp_sitemeta                | 16KB      | 32KB       | 48KB  |
 | wp_users                   | 16KB      | 48KB       | 64KB  |
 | wp_postmeta                | 16KB      | 48KB       | 64KB  |
 | wp_posts                   | 16KB      | 64KB       | 80KB  |
 | wp_signups                 | 16KB      | 64KB       | 80KB  |
 | wp_2_posts                 | 16KB      | 64KB       | 80KB  |
 | wp_3_posts                 | 16KB      | 64KB       | 80KB  |
 | wp_2_comments              | 16KB      | 80KB       | 96KB  |
 | wp_comments                | 16KB      | 80KB       | 96KB  |
 | wp_3_comments              | 16KB      | 80KB       | 96KB  |
 | wp_2_options               | 80KB      | 32KB       | 112KB |
 | wp_3_options               | 80KB      | 32KB       | 112KB |
 | wp_options                 | 176KB     | 32KB       | 208KB |
 +----------------------------+-----------+------------+-------+
 Success: Total size of the database for https://www.example.com is 2.6MB. Data: 1MB; Index: 1.5MBCode language: JavaScript (javascript)

    Enjoy!

  • Quick Tip: Export WordPress SQL output via WP-CLI

    Quick Tip: Export WordPress SQL output via WP-CLI

    If for some reason you can’t run wp db query, but need to export SQL output to a CSV or other file, then have a look at this small WP-CLI command I whipped up that should allow this:

    /**
 * Runs a SQL query against the site database.
 *
 * ## OPTIONS
 *
 * 
 * : SQL Query to run.
 *
 * [--format=]
 * : Render output in a particular format.
 * ---
 * default: table
 * options:
 * - table
 * - csv
 * - json
 * - count
 * - yaml
 * ---
 *
 * [--dry-run=]
 * : Performa a dry run
 *
 * @subcommand sql
 */
public function sql( $args, $assoc_args ) {
     global $wpdb;
 
     $sql     = $args[0];
     $format  = WP_CLI\Utils\get_flag_value( $assoc_args, 'format', 'table' );
     $dry_run = WP_CLI\Utils\get_flag_value( $assoc_args, 'dry-run', 'true' );
 
     // Just some precautions.
     if ( preg_match( '/[update|delete|drop|insert|create|alter|rename|truncate|replace]/i', $sql ) ) {
         WP_CLI::error( 'Please do not modify the database with this command.' );
     }
 
     if ( 'false' !== $dry_run ) {
         WP_CLI::log( WP_CLI::colorize( '%gDRY-RUN%n: <code>EXPLAIN</code> of the query is below: https://mariadb.com/kb/en/explain/' ) );
         $sql = 'EXPLAIN ' . $sql;
     }
 
     // Fetch results from database.
     $results = $wpdb->get_results( $sql, ARRAY_A ); // phpcs:ignore WordPress.DB
 
     // Output data.
     WP_CLI\Utils\format_items( $format, $results, array_keys( $results[0] ) );
}Code language: PHP (php)

    I’d add an example here, but I don’t have any right now that I can share 😐 I’ll try to find one later (don’t hold your breath on me remembering to do that)

  • Deleting Old Post Revisions in WordPress with WP-CLI

    Deleting Old Post Revisions in WordPress with WP-CLI

    Recently I’ve been working with a client who’s site we’re going to soon be migrating. To help with any downtime, we’ve been looking at reducing their database size, which is something around 50-60 gigabytes. After looking through the database, one easy win would be to purge as many post revisions as possible, since their wp_posts table was about 50% revisions 😱

    We couldn’t just mass delete anything with a revision post type though, because the client had some specific needs:

    • Keep all revisions for posts from the last 12 months.
    • Keep all revisions that were made after the post was published.
    • Keep a backup of all revisions deleted.

    To do this, I crafted a custom WP-CLI command to purge these revisions. I’ve accidentally deleted the final version of the script, since it was only a one-run thing, but here’s an earlier version that could be a good starting point for anyone else that has a similar need to prune revisions:

    /**
 * WP-CLI command that deletes pre-publish post revisions for posts older than 12 months.
 *
 * @subcommand prune-revisions [--live] [--verbose]
 */
public function prune_revisions( $args, $assoc_args ) {
	global $wpdb;

	$live    = (bool) $assoc_args[ 'live' ];
	$verbose = (bool) $assoc_args[ 'verbose' ];
	$offset  = 0;
	$limit   = 500;
	$count   = 0;
	$deletes = 0;

	if ( $live ) {
		$output_file = sanitize_file_name( sprintf( 'prune-revisions-backup_%d_%d.csv', get_bloginfo( 'name' ), current_time( 'timestamp', true ) ) );
		$handle      = fopen( $output_file, 'wb' );

		if ( false === $handle ) {
			WP_CLI::error( sprintf( 'Error opening %s for writing!', $output_file ) );
		}

		// Headers.
		$csv_headers = array(
			'ID',
			'post_author',
			'post_date',
			'post_date_gmt',
			'post_content',
			'post_title',
			'post_excerpt',
			'post_status',
			'comment_status',
			'ping_status',
			'post_password',
			'post_name',
			'to_ping',
			'pinged',
			'post_modified',
			'post_modified_gmt',
			'post_content_filtered',
			'post_parent',
			'guid',
			'menu_order',
			'post_type',
			'post_mime_type',
			'comment_count',
			'filter',
		);

		fputcsv(
			$handle,
			$csv_headers
		);
	}

	$count_sql      = 'SELECT COUNT(ID) FROM ' . $wpdb->posts . ' WHERE post_type = "revision"';
	$revision_count = (int) $wpdb->get_row( $count_sql, ARRAY_N )[0];
	$progress       = \WP_CLI\Utils\make_progress_bar( sprintf( 'Checking %s revisions', number_format( $revision_count ) ), $revision_count );

	do {
		$sql       = $wpdb->prepare( 'SELECT ID FROM ' . $wpdb->posts . ' WHERE post_type = "revision" LIMIT %d,%d', $offset, $limit );
		$revisions = $wpdb->get_results( $sql );

		foreach ( $revisions as $revision ) {
			$count++;
			$post_parent_id = wp_get_post_parent_id( $revision->ID );

			// Fail on either 0 or false.
			if ( false == $post_parent_id ) {
				WP_CLI::warning( sprintf( 'Revision %d does not have a parent!  Skipping!', $revision->ID ) );
				continue;
			}

			$revision_modified   = get_post_modified_time( 'U', false, $revision->ID );
			$parent_publish_time = get_post_time( 'U', false, $post_parent_id );

			if ( $parent_publish_time < current_time( 'timestamp') - ( MONTH_IN_SECONDS * 12 ) ) {
				// Post is older than 12 months, safe to delete pre-publish revisions.
				if ( $revision_modified < $parent_publish_time ) {
					if ( $live ) {
						// We're doing it live!
						WP_CLI::log( sprintf( 'Deleting revision %d for post %d. (%d%% done)', $revision->ID, $post_parent_id, ( $count / $revision_count ) * 100 ) );

						// Backup data!
						$output = [];
						$data   = get_post( $revision->ID );

						// Validate the field is set, just in case.  IDK how it couldn't be.
						foreach ( $csv_headers as $field ) {
							$output = isset( $data->$field ) ? $data->$field : '';
						}

						fputcsv( $handle, $output );

						$did_delete = wp_delete_post_revision( $revision->ID );

						// Something went wrong while deleting the revision?
						if ( false === $did_delete || is_wp_error( $did_delete ) ) {
							WP_CLI::warning( sprintf( 'Revision %d for post %d DID NOT DELETE! wp_delete_post_revision returned:', $revision->ID, $post_parent_id ) );
						}
						$deletes++;

						// Pause after lots of db modifications.
						if ( 0 === $deletes % 50 ) {
							if ( $verbose ) {
								WP_CLI::log( sprintf( 'Current Deletes: %d', $deletes ) );
							}
							sleep( 1 );
						}
					} else {
						// Not live, just output info.
						WP_CLI::log( sprintf( 'Will delete revision %d for post %d.', $revision->ID, $post_parent_id ) );
					}
				} else {
					// Revision is after the post has been published.
					if ( $verbose ) {
						WP_CLI::log( sprintf( 'Post-Publish: Will NOT delete Revision %d for post %d.', $revision->ID, $post_parent_id ) );
					}
				}
			} else {
				// Post is too new to prune.
				if ( $verbose ) {
					WP_CLI::log( sprintf( 'Too-New: Will NOT delete Revision %d for post %d.', $revision->ID, $post_parent_id ) );
				}
			}
		}

		// Pause after lots of db reads.
		if ( 0 === $count % 5000 ) {
			if ( $verbose ) {
				WP_CLI::log( sprintf( 'Current Count: %d', $count ) );
			}
			sleep( 1 );
		}

		// Free up memory.
		$this->stop_the_insanity();

		// Paginate.
		if ( count( $revisions ) ) {
			$offset += $limit;
			$progress->tick( $limit );
		} else {
			WP_CLI::warning( 'Possible MySQL Error, retrying in 10 seconds!' );
			sleep( 10 );
		}

	} while ( $count < $revision_count );

	$progress->finish();

	if ( $live ) {
		fclose( $handle );
		WP_CLI::success( sprintf( 'Deleted %d revisions', $deleted ) );
	} else {
		WP_CLI::success( sprintf( 'Processed %d revisions', $revision_count ) );
	}
}Code language: PHP (php)
  • Quick Tip: DreamHost cron and WP-CLI

    Quick Tip: DreamHost cron and WP-CLI

    If you’re hosting your WordPress website on DreamHost, and use their cron system to offload your WordPress faux-cron for better reliability, be careful of what version of PHP you have in your code.

    I recently had an issue where my cron events weren’t firing, and after enabling email output, I ended up with something like this PHP error message:

    Parse error: syntax error, unexpected '?' in /path/to/file.php on line 123

    It turns out that WP-CLI was running PHP 5.x via the DreamHost cron system.  I had PHP 7.x specific code in my theme.
    To fix this, I had to set the WP_CLI_PHP environment variable in my cron job:

    export WP_CLI_PHP=/usr/local/php72/bin/php
wp cron event run --due-now --path=/home/path/to/wp/ --url=https://example.com/Code language: JavaScript (javascript)
  • Disabling WordPress Faux Cron

    Disabling WordPress Faux Cron

    The WordPress WP-Cron system is a decently okay faux cron system, but it has its problems, such as running on frontend requests and not running if no requests are coming through.

    WP-Cron works by: on every page load, a list of scheduled tasks is checked to see what needs to be run. Any tasks scheduled to be run will be run during that page load. WP-Cron does not run constantly as the system cron does; it is only triggered on page load. Scheduling errors could occur if you schedule a task for 2:00PM and no page loads occur until 5:00PM.

    From the WordPress Plugin Handbook

    These are problems because:

    • A heavy cron event can cause severe slowdown on random frontend requests, hurting page speeds.
    • Not running without requests can be bad for sites that are infrequently updated and heavily cached.

    The solution to this is to disable the built-in cron firing that’s done with pageviews, and use a system cron (or other service) to poll for cron events.

    Disabling the cron firing is done by adding this to the wp-config.php file:

    define( 'DISABLE_WP_CRON', true );Code language: JavaScript (javascript)

    For this site specifically, I use the “Cron Jobs” system of DreamHost to run this WP-CLI command every 10 minutes:

    wp cron event run --due-now --path=/path/to/derrick.blog/ --url=https://derrick.blog/Code language: JavaScript (javascript)

    This forces the cron to run and check for ready jobs every 10 minutes.  It’s possible that some cron events might run later than they “should” but in practice, I’ve seen this running more cron jobs than if I relied on page loads.

  • Validating WordPress attachments with WP-CLI

    Validating WordPress attachments with WP-CLI

    I recently worked on migrating a site to a different server and for one reason or another, some of the images did not come over properly. While I could have just re-downloaded and re-imported all of the media, it would have taken quite a while since the media library was well over 100Gb. Instead, I opted to use WP-CLI to help find what images were missing:

    (more…)
Close

Ad-Blocker Not Detected 🛑

Consider installing a browser extension that blocks ads and other malicious scripts in your browser to protect your privacy and security, conserve your expensive data plan, and cut your online carbon footprint. Learn more.