Derrick.Blarg

Tag: performance

  • WordPress Performance: Caching Navigation Menus

    WordPress Performance: Caching Navigation Menus

    Background

    In the before time, WordPress developers used to build themes (and plugins?) using PHP. When we wanted to add a user generated navigation menu to sites, we had to use a function called wp_nav_menu(). Of course, now that we’re in the future, we don’t need to worry about such things.

    But if you’re still using PHP to build WordPress sites, and still using wp_nav_menu() you might not know that these menus can be performance killers!

    Problem!

    Under the hood, nav menus are stored as terms in a nav_menu taxonomy. For large sites with lots of terms and taxonomies, and complex menus (custom walkers, yay!) you can really start to see menus struggle. Sure, this might be only 50-100ms, but that really adds up after millions of pageviews.

    Caching Solution

    One of the solutions you can do us to wrap the wp_nav_menu() calls inside a caching function, like what the Cache Nav Menus plugin does. Of course, this can complicate things, and even require you to fork third party plugins and themes to maintain caching compatability.

    Another option you have is to cheat. By hooking into pre_wp_nav_menu you can cache the nav menus in place. Below is an example I’ve given customers before that shows how you can cache menus in place with a simple (mu) plugin:

    /**
 * Filters and caches the output of a WordPress navigation menu.
 *
 * This function is hooked to the 'pre_wp_nav_menu' action, it generates a unique cache key
 * for every individual menu based on the menu arguments and the last time the menu was modified.
 * This key is then used to store and retrieve cached versions of the menu.
 *
 * @param string|null $output Nav menu output to short-circuit with.
 * @param stdClas     $args   An object containing wp_nav_menu() arguments.
 *
 * @return string|null        Nav menu output.
 */
function wpvip_pre_cache_nav_menu( string|null $output, $args ): string|null {
	/**
	 * Filters whether to enable caching for a specific menu.
	 *
	 * This filter can be used to selectively disable caching for specific WordPress navigation menus.
	 * By default, all menus are cached for an hour.
	 *
	 * @param bool   $enable_cache Whether to enable caching for the menu. Default true.
	 * @param string $args         An object containing wp_nav_menu() arguments.
	 */
	$enable_cache = apply_filters( 'wpvip_pre_cache_nav_menu', true, $args );

	if ( ! $enable_cache ) {
		return $output;
	}

	// Define a unique cache key.
	$cache_key   = $args->menu . ':' . md5( serialize( $args ) ); // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.serialize_serialize
	$cache_group = 'wpvip_pre_cache_nav_menu';

	// Try to get the cached menu.
	$output = wp_cache_get( $cache_key, $cache_group );

	// If the menu isn't cached, generate and cache it.
	if ( false === $output ) {
		$args->echo = false;
		remove_action( 'pre_wp_nav_menu', 'wpvip_pre_cache_nav_menu', 10, 2 );
		$output = wp_nav_menu( $args );
		add_action( 'pre_wp_nav_menu', 'wpvip_pre_cache_nav_menu', 10, 2 );
		wp_cache_set( $cache_key, $output, $cache_group, HOUR_IN_SECONDS );
	}

	return $output;
}
add_action( 'pre_wp_nav_menu', 'wpvip_pre_cache_nav_menu', 10, 2 );Code language: PHP (php)

    Now, due to the weird way that you can call menus via wp_nav_menu() this might require some tweaking depending on your needs (are you using an int, string, or WP_Query to query the desired menu? Why so many choices?)

    This is defaulting to caching for one hour, but you can likely cache for MUCH longer since menus rarely change. You could even cache forever and use the wp_update_nav_menu hook to purge and/or prime the cache.

    Now go away and break some stuff.

  • Matrix Reimagined: Crafting Digital Rain with Bash and ChatGPT

    Matrix Reimagined: Crafting Digital Rain with Bash and ChatGPT

    Just for fun, and I have no idea why I thought about it, I decided to work with ChatGPT (4) to build a simple bash-based version of the Matrix Digital Rain. I know there’s already better versions, like cmatrix, but we do not do things because they are easy. We do them because we are bored.

    I’ve asked ChatGPT to heavily comment the code for us so that we can see exactly what’s going on:

    #!/bin/bash

# This script creates a Matrix-style falling text effect in the terminal.

# Define strings for extra characters (Japanese Katakana) and extended ASCII characters
extra_chars="ｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ"
extended_ascii="│┤┐└┴┬├─┼┘┌≡"

# Define arrays of color codes for a fading green color effect, and a static color
fade_colors=('\033[38;2;0;255;0m' '\033[38;2;0;192;0m' '\033[38;2;0;128;0m' '\033[38;2;0;64;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;32;0m' '\033[38;2;0;16;0m' '\033[38;2;0;8;0m') # Fading green colors
static_color='\033[38;2;0;0;0m' # Static dark green color
white_bold='\033[1;37m' # White and bold for the primary character

# Get terminal dimensions
COLUMNS=$(tput cols) # Number of columns in the terminal
ROWS=$(tput lines) # Number of rows in the terminal


# Hide the cursor for a cleaner effect and clear the screen
echo -ne '\033[?25l'
clear

# Function to generate a random character from the set of extra characters and extended ASCII
random_char() {
	local chars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789${extra_chars}${extended_ascii}"
	echo -n "${chars:RANDOM%${#chars}:1}"
}

# Generate a list of 1000 random characters
random_chars=""
for (( i=0; i<1000; i++ )); do
	random_chars+=$(random_char) # Add a random character to the end of the string
done

# Initialize a counter for cycling through the random characters
char_counter=0 # Counter for cycling through the random characters

# Initialize arrays to keep track of the position and trail characters of each column
positions=() # Array to store the current position in each column
trail_chars=() # Array to store the trail characters in each column
for (( c=1; c<=COLUMNS; c++ )); do
	positions[$c]=$((RANDOM % ROWS)) # Random starting position for each column
	trail_chars[$c]="" # Start with an empty trail for each column
done

# Function to update the display with the falling text effect
update_line() {
	local last_pos=0  # Track the last position to optimize cursor movement

	for (( c=1; c<=COLUMNS; c++ )); do
		# Randomly skip updating some columns to create a dynamic effect
		if [ $((RANDOM % 4)) -ne 0 ]; then
			continue
		fi

		local new_char=${random_chars:$char_counter:1} # Select the next character from the random string
		char_counter=$(( (char_counter + 1) % 1000 )) # Update the counter, cycling back after 1000

		local pos=${positions[$c]} # Current position in this column
		local trail=${trail_chars[$c]} # Current trail of characters in this column

		trail_chars[$c]="${new_char}${trail:0:$((ROWS - 1))}" # Update the trail by adding new character at the top

		# Render the trail of characters
		for (( i=0; i<${#trail}; i++ )); do
			local trail_pos=$((pos - i)) # Calculate the position for each character in the trail
			if [ $trail_pos -ge 0 ] && [ $trail_pos -lt $ROWS ]; then
				local color=${fade_colors[i]:-$static_color} # Choose color from the fade array or static color if beyond the array
				if [ $i -eq 0 ]; then
					color=$white_bold # First character in the trail is white and bold
				fi
				if [ $last_pos -ne $trail_pos ]; then
					printf "%b" "\033[${trail_pos};${c}H" # Move cursor to the right position
					last_pos=$trail_pos
				fi
				printf "%b" "${color}${trail:$i:1}\033[0m" # Print the character with color
			fi
		done

		positions[$c]=$((pos + 1)) # Update the position for the next cycle
		if [ $pos -ge $((ROWS + ${#fade_colors[@]})) ]; then
			positions[$c]=0 # Reset position if it moves off screen
			trail_chars[$c]=""
		fi
	done
}

# Main loop for continuous execution of the update_line function
while true; do
	update_line
done

# Reset terminal settings on exit (show cursor, clear screen, reset text format)
echo -ne '\033[?25h' # Show cursor
clear
tput sgr0 # Reset text format
Code language: PHP (php)

    Challenges Faced

    Developing the Matrix Digital Rain script presented specific challenges, especially in terms of performance. The initial use of tput for cursor manipulation proved inefficient for the dynamic text display. This issue was resolved by switching to printf and ANSI escape sequences, which significantly enhanced the rendering performance.

    Another problem arose with the use of fullwidth Katakana characters, which were incompatible with monospaced fonts, disrupting the visual flow. The solution involved adopting halfwidth Katakana, ensuring better compatibility and preserving the uniformity essential for the Matrix-style effect.

    Another notable challenge emerged in development: the inefficiency of generating random characters on the fly. Due to Bash’s slower handling of string functions, this method significantly hindered performance. To tackle this, a strategic shift was made from real-time character generation to utilizing a predefined lookup table.

    This approach involved generating a large set of pseudorandom characters before entering the main loop of the program. By doing so, I could rapidly access this table during runtime, boosting performance. This change played a crucial role in maintaining fluidity and responsiveness. It also preserved the illusion of randomness, essential for the authentic Matrix effect, thus striking a balance between performance efficiency and visual fidelity.

    If you’d like to see what it looks like, here’s an example:

    So yeah. That’s it I guess? Enjoy!

  • Bash Script: Calculate before/after averages

    Bash Script: Calculate before/after averages

    I’ve been doing some performance testing, and wanted a quick way to test how well or poorly changes affect a site. Normally I’d whip out the ol’ calculator app and do this manually. That got tiring after a while, so instead with the help of ChatGPT, I made this little bash script that will do the work for you:

    #!/bin/bash

# Function to calculate the average of a list of numbers
average() {
	local sum=0
	local count=0

	for num in "$@"; do
		sum=$(echo "$sum + $num" | bc -l)
		count=$((count+1))
	done

	echo "$sum / $count" | bc -l
}

# Parse arguments
for i in "$@"; do
	case $i in
		--before=*)
		BEFORE="${i#*=}"
		shift
		;;
		--after=*)
		AFTER="${i#*=}"
		shift
		;;
		*)
		# unknown option
		;;
	esac
done

# Check if both BEFORE and AFTER parameters are provided
if [ -z "$BEFORE" ] || [ -z "$AFTER" ]; then
	echo "Error: Missing required parameters."
	echo "Usage: $0 --before=<comma-separated-values> --after=<comma-separated-values>"
	exit 1
fi

IFS=',' read -ra BEFORE_LIST <<< "$BEFORE"
IFS=',' read -ra AFTER_LIST <<< "$AFTER"

# Calculate average for before and after lists
BEFORE_AVG=$(printf "%.2f\n" $(average "${BEFORE_LIST[@]}"))
AFTER_AVG=$(printf "%.2f\n" $(average "${AFTER_LIST[@]}"))

echo "Before average: $BEFORE_AVG"
echo "After average: $AFTER_AVG"

# Calculate average percent increase, decrease or no change for the list
if [ "$BEFORE_AVG" != "0.00" ]; then
	PERCENT_CHANGE=$(echo "(($AFTER_AVG - $BEFORE_AVG) / $BEFORE_AVG) * 100" | bc -l)
	if [ "$(echo "$PERCENT_CHANGE > 0" | bc -l)" -eq 1 ]; then
		printf "Average percent increased: %.2f%%\n" "$PERCENT_CHANGE"
	elif [ "$(echo "$PERCENT_CHANGE < 0" | bc -l)" -eq 1 ]; then
		printf "Average percent decreased: %.2f%%\n" "$PERCENT_CHANGE" | tr -d '-'
	else
		echo "No change in average."
	fi
else
	echo "Percent change from before to after: undefined (division by zero)"
fi
Code language: Bash (bash)

    It runs like this:

    $ average.sh --before=13.07,9.75,16.14,7.71,10.32 --after=1.22,1.28,1.13,1.19,1.26
Before average: 11.40
After average: 1.22
Average percent decreased: 89.30%

    In this instance, it was calculating seconds–but you need to remember that it only goes to two decimal places, so if you need something finer you’ll need to adjust the code or your inputs.

    Happy Slacking!

  • 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.

  • Debugging WordPress Hooks: Speed

    Debugging WordPress Hooks: Speed

    If you google debugging WordPress hooks you’ll find a lot of information.

    About 1,180,000 results

    Let’s add another one.

    WordPress hooks are powerful, but also complex under the hood. There’s plenty of topics I could talk about here, but right now I’m only going to talk about speed. How long does it take for a hook to fire and return?

    Some cool work in this area has already been done thanks to Debug Bar Slow Actions and Query Monitor, but outside of something like Xdebug or New Relic, you’ll have a hard time figuring out how long each individual hook callback takes without modifying either WordPress core or each hook call.

    … or maybe not …

    While doing some client debugging for my job at WordPress VIP (did I mention we’re hiring?) I came across the need to do this exact thing. I’ve just finished the code that will make this happen, and I’m releasing it into the wild for everyone to benefit.

    What’s the problem we’re trying to solve? Well, this client has a sporadic issue where posts saving in the admin time out and sometimes fail. We’ve ruled out some potential issues, and are looking at a save_post hook going haywire.

    Now I can capture every single save_post action, what the callback was, and how long it took. Here’s an example for this exact post:

    START: 10:save_post, (Callback: `delete_get_calendar_cache`)
STOP: 10:save_post, Taken 132.084μs (Callback: `delete_get_calendar_cache`)
START: 10:save_post, (Callback: `sharing_meta_box_save`)
STOP: 10:save_post, Taken 15.974μs (Callback: `sharing_meta_box_save`)
START: 10:save_post, (Callback: `Jetpack_Likes_Settings::meta_box_save`)
STOP: 10:save_post, Taken 19.073μs (Callback: `Jetpack_Likes_Settings::meta_box_save`)
START: 10:save_post, (Callback: `SyntaxHighlighter::mark_as_encoded`)
STOP: 10:save_post, Taken 19.073μs (Callback: `SyntaxHighlighter::mark_as_encoded`)
START: 10:save_post, (Callback: `AMP_Post_Meta_Box::save_amp_status`)
STOP: 10:save_post, Taken 16.928μs (Callback: `AMP_Post_Meta_Box::save_amp_status`)
START: 20:save_post, (Callback: `Publicize::save_meta`)
STOP: 20:save_post, Taken 428.915μs (Callback: `Publicize::save_meta`)
START: 9000:save_post, (Callback: `Debug_Bar_Slow_Actions::time_stop`)
STOP: 9000:save_post, Taken 11.921μs (Callback: `Debug_Bar_Slow_Actions::time_stop`)
START: 1:save_post, (Callback: `The_SEO_Framework\Load::_update_post_meta`)
STOP: 1:save_post, Taken 6.016ms (Callback: `The_SEO_Framework\Load::_update_post_meta`)
START: 1:save_post, (Callback: `The_SEO_Framework\Load::_save_inpost_primary_term`)
STOP: 1:save_post, Taken 1.535ms (Callback: `The_SEO_Framework\Load::_save_inpost_primary_term`)
START: 10:save_post, (Callback: `delete_get_calendar_cache`)
STOP: 10:save_post, Taken 179.052μs (Callback: `delete_get_calendar_cache`)
START: 10:save_post, (Callback: `sharing_meta_box_save`)
STOP: 10:save_post, Taken 247.002μs (Callback: `sharing_meta_box_save`)
START: 10:save_post, (Callback: `Jetpack_Likes_Settings::meta_box_save`)
STOP: 10:save_post, Taken 25.988μs (Callback: `Jetpack_Likes_Settings::meta_box_save`)
START: 10:save_post, (Callback: `The_SEO_Framework\Load::delete_excluded_ids_cache`)
STOP: 10:save_post, Taken 185.966μs (Callback: `The_SEO_Framework\Load::delete_excluded_ids_cache`)
START: 10:save_post, (Callback: `SyntaxHighlighter::mark_as_encoded`)
STOP: 10:save_post, Taken 15.020μs (Callback: `SyntaxHighlighter::mark_as_encoded`)
START: 10:save_post, (Callback: `AMP_Post_Meta_Box::save_amp_status`)
STOP: 10:save_post, Taken 12.875μs (Callback: `AMP_Post_Meta_Box::save_amp_status`)
START: 20:save_post, (Callback: `Publicize::save_meta`)
STOP: 20:save_post, Taken 377.893μs (Callback: `Publicize::save_meta`)
START: 9000:save_post, (Callback: `Debug_Bar_Slow_Actions::time_stop`)
STOP: 9000:save_post, Taken 14.067μs (Callback: `Debug_Bar_Slow_Actions::time_stop`)Code language: CSS (css)

    So how does it work?

    1. We add an all action that will fire for every other action.
    2. In the all callback, we make sure we’re looking for the correct hook.
    3. We then build an array to store some data, use the $wp_filter global to fill out information such as the priority and the callback, and store the start time.
    4. Next we have to add a new action to run for our hook right before the callback we want to time. We use the fact that, even though add_action() is supposed to use an int for the priority, it will also accept a string. We add new hooks, and re-prioritze all of the existing hooks with floats that are stringified.
    5. This allows us to capture the start time and end time of each individual callback, instead of the priority group as a whole.

    Of course, this does add a tiny bit of overhead, and could cause some problems if any other plugins use stringified hook priorities, or other odd issues–so be careful 🙂

    Finally, here’s the code:

    class VIP_Hook_Timeline {
	public $hook;
	public $callbacks     = [];
	public $callback_mod  = 0.0001;
	public $callback_mods = [];

	public function __construct( $hook ) {
		$this->hook = $hook;
		add_action( 'all', array( $this, 'start' ) );
	}

	public function start() {
		// We only want to get a timeline for one hook.
		if ( $this->hook !== current_filter() ) {
			return;
		}

		global $wp_filter;

		// Iterate over each priority level and set up array.
		foreach( $wp_filter[ $this->hook ] as $priority => $callback ) {
			// Make the mod counter if not exists.
			if ( ! isset( $this->callback_mods[ $priority ] ) ) {
				$this->callback_mods[ $priority ] = $priority - $this->callback_mod;
			}

			// Make the array if not exists.
			if ( ! is_array( $this->callbacks[ $priority ] ) ) {
				$this->callbacks[ $priority ] = [];
			}

			// Iterate over each callback and set up array.
			foreach( array_keys( $callback ) as $callback_func ) {
				if ( ! is_array( $this->callbacks[ $priority ][ $callback_func ] ) ) {
					$this->callbacks[ $priority ][ $callback_func ] = [ 'start' => 0, 'stop' => 0 ];
				}
			}
		}

		foreach( $this->callbacks as $priority => $callback ) {
			foreach ( array_keys( $callback ) as $callback_func ) {

				// Get data befmore we move things around.
				$human_callback = $this->get_human_callback( $wp_filter[ $this->hook ][ $priority ][$callback_func] );

				// Modify the priorities.
				$pre_callback_priority = $this->callback_mods[ $priority ];
				$this->callback_mods[ $priority ] = $this->callback_mods[ $priority ] + $this->callback_mod;

				$new_callback_priority = $this->callback_mods[ $priority ];
				$this->callback_mods[ $priority ] = $this->callback_mods[ $priority ] + $this->callback_mod;

				$post_callback_priority = $this->callback_mods[ $priority ];
				$this->callback_mods[ $priority ] = $this->callback_mods[ $priority ] + $this->callback_mod;

				// Move the callback to our "new" priority.
				if ( $new_callback_priority != $priority ) {
					$wp_filter[ $this->hook ]->callbacks[ strval( $new_callback_priority ) ][ $callback_func ] = $wp_filter[ $this->hook ]->callbacks[ $priority ][ $callback_func ];
					unset( $wp_filter[ $this->hook ]->callbacks[ $priority ][ $callback_func ] );
					if ( empty( $wp_filter[ $this->hook ]->callbacks[ $priority ] ) ) {
						unset( $wp_filter[ $this->hook ]->callbacks[ $priority ] );
					}
				}

				// Add a new action right before the one we want to debug to capture start time.
				add_action( $this->hook, function( $value = null ) use ( $callback_func, $priority, $human_callback ) {
					$this->callbacks[ $priority ][ $callback_func ]['start'] = microtime( true );

					// Uncomment this if you just want to dump data to the PHP error log, otherwise add your own logic.
					//$message = 'START: %d:%s, (Callback: `%s`)';
					// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
					//error_log( sprintf( $message,
					//	$priority,
					//	$this->hook,
					//	$human_callback,
					//) );

					// Just in case it's a filter, return.
					return $value;
				}, strval( $pre_callback_priority ) );

				// Add a new action right after the one we want to debug to capture end time.
				add_action( $this->hook, function( $value = null ) use ( $callback_func, $priority, $human_callback ) {
					$this->callbacks[ $priority ][ $callback_func ]['stop'] = microtime( true );

					// Uncomment this if you just want to dump data to the PHP error log, otherwise add your own logic.
					//$message = 'STOP: %d:%s, Taken %s (Callback: `%s`)';
					// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
					//error_log( sprintf( $message,
					//	$priority,
					//	$this->hook,
					//	$this->get_human_diff( $priority, $callback_func ),
					//	$human_callback,
					//) );

					// Just in case it's a filter, return.
					return $value;
				}, strval( $post_callback_priority ) );
				
			}
		}
	}

	public function get_human_callback( $callback ) {
		$human_callback = '[UNKNOWN HOOK]';
		if ( is_array( $callback['function'] ) && count( $callback['function'] ) == 2 ) {
			list( $object_or_class, $method ) = $callback['function'];
			if ( is_object( $object_or_class ) ) {
				$object_or_class = get_class( $object_or_class );
			}
			$human_callback =  sprintf( '%s::%s', $object_or_class, $method );
		} elseif ( is_object( $callback['function'] ) ) {
			// Probably an anonymous function.
			$human_callback =  get_class( $callback['function'] );
		} else {
			$human_callback =  $callback['function'];
		}
		return $human_callback;
	}

	public function get_start( $priority, $callback_func ) {
		return (float) $this->callbacks[ $priority ][ $callback_func ]['start'];
	}

	public function get_stop( $priority, $callback_func ) {
		return (float) $this->callbacks[ $priority ][ $callback_func ]['stop'];
	}

	public function get_diff( $priority, $callback_func ) {
		return (float) ( $this->get_stop( $priority, $callback_func ) - $this->get_start( $priority, $callback_func ) );
	}

	public function get_human_diff( $priority, $callback_func ) {
		$seconds = $this->get_diff( $priority, $callback_func );

		// Seconds.
		if ( $seconds >= 1 || $seconds == 0 ) {
			return number_format( $seconds, 3 ) . 's';
		}

		// Milliseconds.
		if ( $seconds >= .001 ) {
			return number_format( $seconds * 1000, 3 ) . 'ms';
		}

		// Microseconds.
		if ( $seconds >= .000001 ) {
			return number_format( $seconds * 1000000, 3 ) . 'μs';
		}

		// Nanoseconds.
		if ( $seconds >= .000000001 ) {
			// WOW THAT'S FAST!
			return number_format( $seconds * 1000000000, 3 ) . 'ns';
		}

		return $seconds . 's?';
	}
}
new VIP_Hook_Timeline( 'save_post' );Code language: PHP (php)

  • 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.

  • Query Caching (and a little extra)

    Query Caching (and a little extra)

    By default, WordPress does not cache WP_Query queries.  Doing so can greatly improve performance.  The way I do this is via the Advanced Post Cache plugin:

    All up in your WP_Query, caching the things.
    https://github.com/Automattic/advanced-post-cache
    17 forks.
    62 stars.
    14 open issues.

    Recent commits:

    By running this plugin (hopefully as an mu-plugin) with a persistent object cache, WP_Query calls, along with get_post() calls (only if suppress_filters is false) will be cached.

    Bonus!

    Now that we’re caching queries, here’s how I do a little extra caching to squeeze out a tiny bit more performance:

    <?php
// By default Jetpack does not cache responses from Instagram oembeds.
add_filter( 'instagram_cache_oembed_api_response_body', '__return_true' );

// Cache WP Dashboard Recent Posts Query
add_filter( 'dashboard_recent_posts_query_args', 'cache_dashboard_recent_posts_query_args', 10, 1 );
function cache_dashboard_recent_posts_query_args( $query_args ) {
	$query_args['cache_results'] = true;
	$query_args['suppress_filters'] = false;
	return $query_args;
}

// Cache WP Dashboard Recent Drafts Query
add_filter( 'dashboard_recent_drafts_query_args', 'cache_dashboard_recent_drafts_query_args', 10, 1 );
function cache_dashboard_recent_drafts_query_args( $query_args ) {
	$query_args['suppress_filters'] = false;
	return $query_args;
}

// Cache comment counts, https://github.com/Automattic/vip-code-performance/blob/master/core-fix-comment-counts-caching.php
add_filter( 'wp_count_comments', 'wpcom_vip_cache_full_comment_counts', 10, 2 );
function wpcom_vip_cache_full_comment_counts( $counts = false , $post_id = 0 ){
	//We are only caching the global comment counts for now since those are often in the millions while the per page one is usually more reasonable.
	if ( 0 !== $post_id ) {
		return $counts;
	}

	$cache_key = "vip-comments-{$post_id}";
	$stats_object = wp_cache_get( $cache_key );

	//retrieve comments in the same way wp_count_comments() does
	if ( false === $stats_object ) {
		$stats = get_comment_count( $post_id );
		$stats['moderated'] = $stats['awaiting_moderation'];
		unset( $stats['awaiting_moderation'] );
		$stats_object = (object) $stats;

		wp_cache_set( $cache_key, $stats_object, 'default', 30 * MINUTE_IN_SECONDS );
	}

	return $stats_object;
}

// Cache monthly media array.
add_filter( 'media_library_months_with_files', 'wpcom_vip_media_library_months_with_files' );
function wpcom_vip_media_library_months_with_files() {
	$months = wp_cache_get( 'media_library_months_with_files', 'extra-caching' );

	if ( false === $months ) {
		global $wpdb;
		$months = $wpdb->get_results( $wpdb->prepare( "
			SELECT DISTINCT YEAR( post_date ) AS year, MONTH( post_date ) AS month
			FROM $wpdb->posts
			WHERE post_type = %s
			ORDER BY post_date DESC
			", 'attachment' )
		);
		wp_cache_set( 'media_library_months_with_files', $months, 'extra-caching' );
	}

	return $months;
}

add_action( 'add_attachment', 'media_library_months_with_files_bust_cache' );
function media_library_months_with_files_bust_cache( $post_id ) {
	if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
		return;
	}

	// What month/year is the most recent attachment?
	global $wpdb;
	$months = $wpdb->get_results( $wpdb->prepare( "
			SELECT DISTINCT YEAR( post_date ) AS year, MONTH( post_date ) AS month
			FROM $wpdb->posts
			WHERE post_type = %s
			ORDER BY post_date DESC
			LIMIT 1
		", 'attachment' )
	);

	// Simplify by assigning the object to $months
	$months = array_shift( array_values( $months ) );

	// Compare the dates of the new, and most recent, attachment
	if (
		! $months->year == get_the_time( 'Y', $post_id ) &&
		! $months->month == get_the_time( 'm', $post_id )
	) {
		// the new attachment is not in the same month/year as the
		// most recent attachment, so we need to refresh the transient
		wp_cache_delete( 'media_library_months_with_files', 'extra-caching' );
	}
}Code language: HTML, XML (xml)

  • iPhone – Dawn of The First Day

    iPhone – Dawn of The First Day

    The first thing that I’ve learned during my transition to iOS is that the mobile keyboard experience is very subpar compared to Android. The stock iOS keyboard is bad, but even using a third party keyboard like Gboard doesn’t even come close to the experience on Android. The layout requires so many more taps to do simple things like numbers and punctuation.

    Secondly, the down firing speakers of the iPhone 6s+ are absolutely terrible for consuming media–at least compared to the Nexus 6 and it’s stereo front firing speakers. Trying to watch a video on YouTube, I found myself having to hold the iPhone in an uncomfortable position to get even mediocre sound.

    Now, that’s not to say that it’s all bad. The speed of this old iPhone, compared to my Nexus 6 is blazingly fast. All of the OS transitions are buttery smooth, there is absolutely no lag to be seen, and the camera can take pictures faster than I can tap!

    The iOS experience doesn’t seem to be created for one-handed use, since I constantly have to stretch far to the top of the screen or exit lazy mode and get my second hand out to tap something at the top. Android’s bottom navigation bar is definitely a better user experience.

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.