spawn_cron

The timeline below displays how wordpress function spawn_cron has changed across different WordPress versions. If a version is not listed, refer to the next available version below.

WordPress Version: 6.5

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = (float) get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // Don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    // Confidence check.
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // Flush any buffers and send the headers.
        wp_ob_end_flush_all();
        flush();
        require_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 6.4

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = (float) get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // Don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    // Sanity check.
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // Flush any buffers and send the headers.
        wp_ob_end_flush_all();
        flush();
        require_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 6.3

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // Don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    // Sanity check.
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // Flush any buffers and send the headers.
        wp_ob_end_flush_all();
        flush();
        require_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 5.4

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // Don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    // Sanity check.
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // Flush any buffers and send the headers.
        wp_ob_end_flush_all();
        flush();
        include_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 5.3

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    //sanity check
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        wp_ob_end_flush_all();
        flush();
        include_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 5.1

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 * @since 5.1.0 Return values added.
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 * @return bool True if spawned, false if no events spawned.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return false;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return false;
    }
    //sanity check
    $crons = wp_get_ready_cron_jobs();
    if (empty($crons)) {
        return false;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return false;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return false;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return true;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    $result = wp_remote_post($cron_request['url'], $cron_request['args']);
    return !is_wp_error($result);
}

WordPress Version: 4.7

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @param int $gmt_time Optional. Unix timestamp (UTC). Default 0 (current time is used).
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * Get the cron lock, which is a Unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.6

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @param int $gmt_time Optional. Unix timestamp. Default 0 (current time is used).
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * Get the cron lock, which is a unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filters the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.5

/**
 * Sends a request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @param int $gmt_time Optional. Unix timestamp. Default 0 (current time is used).
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * Get the cron lock, which is a unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     * @since 4.5.0 The `$doing_wp_cron` parameter was added.
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     * @param string $doing_wp_cron The unix timestamp of the cron lock.
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )), $doing_wp_cron);
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.4

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * Get the cron lock, which is a unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if ('GET' !== $_SERVER['REQUEST_METHOD'] || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-wp-http-streams.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.3

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * Get the cron lock, which is a unix timestamp of when the last cron was spawned
     * and has not finished running.
     *
     * Multiple processes on multiple web servers can run this code concurrently,
     * this lock attempts to make spawning as atomic as possible.
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if (!empty($_POST) || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    // Set the cron lock with the current unix timestamp, when the cron is being spawned.
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-http.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.1

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @return null Cron could not be spawned, because it is not needed to run.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * multiple processes on multiple web servers can run this code concurrently
     * try to make this as atomic as possible by setting doing_cron switch
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if (!empty($_POST) || defined('DOING_AJAX') || defined('XMLRPC_REQUEST')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-http.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 4.0

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @return null Cron could not be spawned, because it is not needed to run.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * multiple processes on multiple web servers can run this code concurrently
     * try to make this as atomic as possible by setting doing_cron switch
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if (!empty($_POST) || defined('DOING_AJAX')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether SSL should be verified for the request. Default false.
     *     }
     * }
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-http.php */
        'sslverify' => apply_filters('https_local_ssl_verify', false),
    )));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 3.8

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @return null Cron could not be spawned, because it is not needed to run.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * multiple processes on multiple web servers can run this code concurrently
     * try to make this as atomic as possible by setting doing_cron switch
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if (!empty($_POST) || defined('DOING_AJAX')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    /**
     * Filter the cron request arguments.
     *
     * @since 3.5.0
     *
     * @param array $cron_request_array {
     *     An array of cron request URL arguments.
     *
     *     @type string $url  The cron request URL.
     *     @type int    $key  The 22 digit GMT microtime.
     *     @type array  $args {
     *         An array of cron request arguments.
     *
     *         @type int  $timeout   The request timeout in seconds. Default .01 seconds.
     *         @type bool $blocking  Whether to set blocking for the request. Default false.
     *         @type bool $sslverify Whether to sslverify. Default true.
     *     }
     * }
     */
    $cron_request = apply_filters('cron_request', array('url' => add_query_arg('doing_wp_cron', $doing_wp_cron, site_url('wp-cron.php')), 'key' => $doing_wp_cron, 'args' => array(
        'timeout' => 0.01,
        'blocking' => false,
        /** This filter is documented in wp-includes/class-http.php */
        'sslverify' => apply_filters('https_local_ssl_verify', true),
    )));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}

WordPress Version: 3.7

/**
 * Send request to run cron through HTTP request that doesn't halt page loading.
 *
 * @since 2.1.0
 *
 * @return null Cron could not be spawned, because it is not needed to run.
 */
function spawn_cron($gmt_time = 0)
{
    if (!$gmt_time) {
        $gmt_time = microtime(true);
    }
    if (defined('DOING_CRON') || isset($_GET['doing_wp_cron'])) {
        return;
    }
    /*
     * multiple processes on multiple web servers can run this code concurrently
     * try to make this as atomic as possible by setting doing_cron switch
     */
    $lock = get_transient('doing_cron');
    if ($lock > $gmt_time + 10 * MINUTE_IN_SECONDS) {
        $lock = 0;
    }
    // don't run if another process is currently running it or more than once every 60 sec.
    if ($lock + WP_CRON_LOCK_TIMEOUT > $gmt_time) {
        return;
    }
    //sanity check
    $crons = _get_cron_array();
    if (!is_array($crons)) {
        return;
    }
    $keys = array_keys($crons);
    if (isset($keys[0]) && $keys[0] > $gmt_time) {
        return;
    }
    if (defined('ALTERNATE_WP_CRON') && ALTERNATE_WP_CRON) {
        if (!empty($_POST) || defined('DOING_AJAX')) {
            return;
        }
        $doing_wp_cron = sprintf('%.22F', $gmt_time);
        set_transient('doing_cron', $doing_wp_cron);
        ob_start();
        wp_redirect(add_query_arg('doing_wp_cron', $doing_wp_cron, wp_unslash($_SERVER['REQUEST_URI'])));
        echo ' ';
        // flush any buffers and send the headers
        while (@ob_end_flush()) {
        }
        flush();
        WP_DEBUG ? include_once ABSPATH . 'wp-cron.php' : @include_once ABSPATH . 'wp-cron.php';
        return;
    }
    $doing_wp_cron = sprintf('%.22F', $gmt_time);
    set_transient('doing_cron', $doing_wp_cron);
    $cron_request = apply_filters('cron_request', array('url' => site_url('wp-cron.php?doing_wp_cron=' . $doing_wp_cron), 'key' => $doing_wp_cron, 'args' => array('timeout' => 0.01, 'blocking' => false, 'sslverify' => apply_filters('https_local_ssl_verify', true))));
    wp_remote_post($cron_request['url'], $cron_request['args']);
}