Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
59.46% covered (warning)
59.46%
88 / 148
33.33% covered (danger)
33.33%
5 / 15
CRAP
0.00% covered (danger)
0.00%
0 / 1
Heartbeat
59.46% covered (warning)
59.46%
88 / 148
33.33% covered (danger)
33.33%
5 / 15
282.14
0.00% covered (danger)
0.00%
0 / 1
 init
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
2
 __construct
80.00% covered (warning)
80.00%
8 / 10
0.00% covered (danger)
0.00%
0 / 1
5.20
 cron_exec
76.92% covered (warning)
76.92%
10 / 13
0.00% covered (danger)
0.00%
0 / 1
7.60
 generate_stats_array
100.00% covered (success)
100.00%
5 / 5
100.00% covered (success)
100.00%
1 / 1
2
 get_environment_stats
78.57% covered (warning)
78.57%
22 / 28
0.00% covered (danger)
0.00%
0 / 1
12.19
 permit_ssl
17.86% covered (danger)
17.86%
5 / 28
0.00% covered (danger)
0.00%
0 / 1
53.89
 get_ssl_test_error
100.00% covered (success)
100.00%
7 / 7
100.00% covered (success)
100.00%
1 / 1
4
 get_active_plugins
57.14% covered (warning)
57.14%
4 / 7
0.00% covered (danger)
0.00%
0 / 1
3.71
 jetpack_xmlrpc_methods
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 xmlrpc_data_response
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
6
 deactivate
80.00% covered (warning)
80.00%
4 / 5
0.00% covered (danger)
0.00%
0 / 1
2.03
 cli_callback
0.00% covered (danger)
0.00%
0 / 17
0.00% covered (danger)
0.00%
0 / 1
30
 initialize_rest_api
100.00% covered (success)
100.00%
15 / 15
100.00% covered (success)
100.00%
1 / 1
1
 rest_heartbeat_data
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 rest_heartbeat_data_permission_check
80.00% covered (warning)
80.00%
4 / 5
0.00% covered (danger)
0.00%
0 / 1
3.07
1<?php
2/**
3 * Jetpack Heartbeat package.
4 *
5 * @package  automattic/jetpack-connection
6 */
7
8namespace Automattic\Jetpack;
9
10use Automattic\Jetpack\Connection\Rest_Authentication;
11use Automattic\Jetpack\Connection\REST_Connector;
12use Automattic\Jetpack\Connection\Utils;
13use Jetpack_Options;
14use WP_CLI;
15use WP_Error;
16use WP_REST_Request;
17use WP_REST_Server;
18
19/**
20 * Heartbeat sends a batch of stats to wp.com once a day
21 */
22class Heartbeat {
23
24    /**
25     * Holds the singleton instance of this class
26     *
27     * @since 1.0.0
28     * @since-jetpack 2.3.3
29     * @var Heartbeat
30     */
31    private static $instance = false;
32
33    /**
34     * Cronjob identifier
35     *
36     * @var string
37     */
38    private $cron_name = 'jetpack_v2_heartbeat';
39
40    /**
41     * Singleton
42     *
43     * @since 1.0.0
44     * @since-jetpack 2.3.3
45     * @static
46     * @return Heartbeat
47     */
48    public static function init() {
49        if ( ! self::$instance ) {
50            self::$instance = new Heartbeat();
51        }
52
53        return self::$instance;
54    }
55
56    /**
57     * Constructor for singleton
58     *
59     * @since 1.0.0
60     * @since-jetpack 2.3.3
61     */
62    private function __construct() {
63
64        // Schedule the task.
65        add_action( $this->cron_name, array( $this, 'cron_exec' ) );
66
67        if ( ! wp_next_scheduled( $this->cron_name ) ) {
68            // Deal with the old pre-3.0 weekly one.
69            $timestamp = wp_next_scheduled( 'jetpack_heartbeat' );
70            if ( $timestamp ) {
71                wp_unschedule_event( $timestamp, 'jetpack_heartbeat' );
72            }
73
74            wp_schedule_event( time(), 'daily', $this->cron_name );
75        }
76
77        add_filter( 'jetpack_xmlrpc_unauthenticated_methods', array( __CLASS__, 'jetpack_xmlrpc_methods' ) );
78
79        if ( defined( 'WP_CLI' ) && WP_CLI ) {
80            WP_CLI::add_command( 'jetpack-heartbeat', array( $this, 'cli_callback' ) );
81        }
82
83        add_action( 'rest_api_init', array( $this, 'initialize_rest_api' ) );
84    }
85
86    /**
87     * Method that gets executed on the wp-cron call
88     *
89     * @since 1.0.0
90     * @since-jetpack 2.3.3
91     * @global string $wp_version
92     */
93    public function cron_exec() {
94
95        $a8c_mc_stats = new A8c_Mc_Stats();
96
97        /*
98         * This should run daily.  Figuring in for variances in
99         * WP_CRON, don't let it run more than every 23 hours at most.
100         *
101         * i.e. if it ran less than 23 hours ago, fail out.
102         */
103        $last = (int) Jetpack_Options::get_option( 'last_heartbeat' );
104        if ( $last && ( $last + DAY_IN_SECONDS - HOUR_IN_SECONDS > time() ) ) {
105            return;
106        }
107
108        /*
109         * Check for an identity crisis
110         *
111         * If one exists:
112         * - Bump stat for ID crisis
113         * - Email site admin about potential ID crisis
114         */
115
116        // Coming Soon!
117
118        foreach ( self::generate_stats_array( 'v2-' ) as $key => $value ) {
119            if ( is_array( $value ) ) {
120                foreach ( $value as $v ) {
121                    $a8c_mc_stats->add( $key, (string) $v );
122                }
123            } else {
124                $a8c_mc_stats->add( $key, (string) $value );
125            }
126        }
127
128        Jetpack_Options::update_option( 'last_heartbeat', time() );
129
130        // Wait for each response, unlike do_server_side_stats(): a dropped heartbeat is not retried for a day.
131        foreach ( $a8c_mc_stats->get_stats_urls() as $url ) {
132            $a8c_mc_stats->do_server_side_stat( $url );
133        }
134
135        /**
136         * Fires when we synchronize all registered options on heartbeat.
137         *
138         * @since 3.3.0
139         */
140        do_action( 'jetpack_heartbeat' );
141    }
142
143    /**
144     * Generates heartbeat stats data.
145     *
146     * @param string $prefix Prefix to add before stats identifier.
147     *
148     * @return array The stats array.
149     */
150    public static function generate_stats_array( $prefix = '' ) {
151
152        /**
153         * This filter is used to build the array of stats that are bumped once a day by Jetpack Heartbeat.
154         *
155         * Filter the array and add key => value pairs where
156         * * key is the stat group name
157         * * value is the stat name.
158         *
159         * Example:
160         * add_filter( 'jetpack_heartbeat_stats_array', function( $stats ) {
161         *    $stats['is-https'] = is_ssl() ? 'https' : 'http';
162         * });
163         *
164         * This will bump the stats for the 'is-https/https' or 'is-https/http' stat.
165         *
166         * @param array  $stats The stats to be filtered.
167         * @param string $prefix The prefix that will automatically be added at the begining at each stat group name.
168         */
169        $stats  = apply_filters( 'jetpack_heartbeat_stats_array', array(), $prefix );
170        $return = array();
171
172        // Apply prefix to stats.
173        foreach ( $stats as $stat => $value ) {
174            $return[ "$prefix$stat" ] = $value;
175        }
176
177        return $return;
178    }
179
180    /**
181     * Generates the site environment stats that are reported in the heartbeat.
182     *
183     * These describe the host environment (WordPress/PHP versions, site configuration, etc.)
184     * rather than the Jetpack plugin itself, so they live in the Connection package and are
185     * reported for every connected site, including standalone-connection installs.
186     *
187     * @since 8.7.9
188     *
189     * @return array The environment stats array, keyed by unprefixed stat name.
190     */
191    public static function get_environment_stats() {
192        $stats = array();
193
194        $stats['wp-version']   = get_bloginfo( 'version' );
195        $stats['php-version']  = PHP_VERSION;
196        $stats['wp-branch']    = (float) get_bloginfo( 'version' );
197        $stats['php-branch']   = (float) PHP_VERSION;
198        $stats['public']       = Jetpack_Options::get_option( 'public' );
199        $stats['ssl']          = self::permit_ssl();
200        $stats['is-https']     = is_ssl() ? 'https' : 'http';
201        $stats['language']     = get_bloginfo( 'language' );
202        $stats['charset']      = get_bloginfo( 'charset' );
203        $stats['is-multisite'] = is_multisite() ? 'multisite' : 'singlesite';
204        $stats['plugins']      = implode( ',', self::get_active_plugins() );
205
206        if ( function_exists( 'get_mu_plugins' ) ) {
207            $stats['mu-plugins'] = implode( ',', array_keys( get_mu_plugins() ) );
208        }
209
210        if ( function_exists( 'get_space_used' ) ) { // Only available in multisite.
211            $space_used = get_space_used();
212        } else {
213            // This is the same as `get_space_used`, except it does not apply the short-circuit filter.
214            $upload_dir = wp_upload_dir();
215            $space_used = get_dirsize( $upload_dir['basedir'] ) / MB_IN_BYTES;
216        }
217
218        $stats['space-used'] = $space_used;
219
220        // is-multi-network can have three values, `single-site`, `single-network`, and `multi-network`.
221        $stats['is-multi-network'] = 'single-site';
222        if ( is_multisite() ) {
223            $stats['is-multi-network'] = ( new Status() )->is_multi_network() ? 'multi-network' : 'single-network';
224        }
225
226        if ( ! empty( $_SERVER['SERVER_ADDR'] ) || ! empty( $_SERVER['LOCAL_ADDR'] ) ) {
227            $ip     = ! empty( $_SERVER['SERVER_ADDR'] ) ? wp_unslash( $_SERVER['SERVER_ADDR'] ) : wp_unslash( $_SERVER['LOCAL_ADDR'] ); // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Sanitized just below.
228            $ip_arr = array_map( 'intval', explode( '.', $ip ) );
229            if ( 4 === count( $ip_arr ) ) {
230                $stats['ip-2-octets'] = implode( '.', array_slice( $ip_arr, 0, 2 ) );
231            }
232        }
233
234        return $stats;
235    }
236
237    /**
238     * Checks whether the site can connect to WordPress.com over SSL.
239     *
240     * This is the canonical SSL connectivity check. It caches both the boolean result (in the
241     * `jetpack_https_test` transient) and a structured failure reason (via
242     * {@see self::get_ssl_test_error()}) so a single check serves both the `ssl` heartbeat stat
243     * and consumers such as the Jetpack plugin's admin notice, which renders a localized message
244     * from the reason code. This avoids duplicate network checks and keeps translated strings out
245     * of the package.
246     *
247     * @since 8.7.9
248     *
249     * @param bool $force_recheck Force the SSL recheck instead of using the cached result.
250     * @return bool Whether the site can connect to WordPress.com over SSL.
251     */
252    public static function permit_ssl( $force_recheck = false ) {
253        $ssl = false;
254        if ( ! $force_recheck ) {
255            $ssl = get_transient( 'jetpack_https_test' );
256        }
257
258        if ( $force_recheck || false === $ssl ) {
259            $error = array(
260                'code'   => '',
261                'detail' => '',
262            );
263
264            $api_base = Constants::get_constant( 'JETPACK__API_BASE' );
265            if ( ! $api_base ) {
266                $api_base = Utils::DEFAULT_JETPACK__API_BASE;
267            }
268
269            if ( ! str_starts_with( $api_base, 'https' ) ) {
270                $ssl = 0;
271            } else {
272                $ssl = 1;
273
274                if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
275                    $ssl           = 0;
276                    $error['code'] = 'no_ssl_support';
277                } else {
278                    $response = wp_remote_get( $api_base . 'test/1/' );
279                    if ( is_wp_error( $response ) ) {
280                        $ssl           = 0;
281                        $error['code'] = 'no_ssl_support';
282                    } elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
283                        $ssl             = 0;
284                        $error['code']   = 'bad_response';
285                        $error['detail'] = wp_remote_retrieve_body( $response );
286                    }
287                }
288            }
289            set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
290            set_transient( 'jetpack_https_test_error', $error, DAY_IN_SECONDS );
291        }
292
293        return (bool) $ssl;
294    }
295
296    /**
297     * Returns the structured reason for the last SSL connectivity failure.
298     *
299     * Consumers can map the returned reason code to a localized message. The `detail` value
300     * carries any additional context (e.g. the unexpected response body for `bad_response`).
301     *
302     * @since 8.7.9
303     *
304     * @return array {
305     *     The last SSL test error.
306     *
307     *     @type string $code   Reason code: '' (no error), 'no_ssl_support', or 'bad_response'.
308     *     @type string $detail Additional context for the failure, if any.
309     * }
310     */
311    public static function get_ssl_test_error() {
312        $error = get_transient( 'jetpack_https_test_error' );
313
314        if ( ! is_array( $error ) ) {
315            $error = array();
316        }
317
318        return array(
319            'code'   => isset( $error['code'] ) ? (string) $error['code'] : '',
320            'detail' => isset( $error['detail'] ) ? (string) $error['detail'] : '',
321        );
322    }
323
324    /**
325     * Gets all plugins currently active, regardless of whether they're traditionally
326     * activated or network activated.
327     *
328     * Ported from the Jetpack plugin so the `plugins` heartbeat stat can be generated from
329     * the Connection package. This is the canonical implementation; the Jetpack plugin's
330     * `Jetpack::get_active_plugins()` delegates to it.
331     *
332     * @since 8.7.9
333     *
334     * @return array
335     */
336    public static function get_active_plugins() {
337        $active_plugins = (array) get_option( 'active_plugins', array() );
338
339        if ( is_multisite() ) {
340            // Due to legacy code, active_sitewide_plugins stores them in the keys,
341            // whereas active_plugins stores them in the values.
342            $network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
343            if ( $network_plugins ) {
344                $active_plugins = array_merge( $active_plugins, $network_plugins );
345            }
346        }
347
348        sort( $active_plugins );
349
350        return array_unique( $active_plugins );
351    }
352
353    /**
354     * Registers jetpack.getHeartbeatData xmlrpc method
355     *
356     * @param array $methods The list of methods to be filtered.
357     * @return array $methods
358     */
359    public static function jetpack_xmlrpc_methods( $methods ) {
360        $methods['jetpack.getHeartbeatData'] = array( __CLASS__, 'xmlrpc_data_response' );
361        return $methods;
362    }
363
364    /**
365     * Handles the response for the jetpack.getHeartbeatData xmlrpc method
366     *
367     * @param array $params The parameters received in the request.
368     * @return array $params all the stats that heartbeat handles.
369     */
370    public static function xmlrpc_data_response( $params = array() ) {
371        // The WordPress XML-RPC server sets a default param of array()
372        // if no argument is passed on the request and the method handlers get this array in $params.
373        // generate_stats_array() needs a string as first argument.
374        $params = empty( $params ) ? '' : $params;
375        return self::generate_stats_array( $params );
376    }
377
378    /**
379     * Clear scheduled events
380     *
381     * @return void
382     */
383    public function deactivate() {
384        // Deal with the old pre-3.0 weekly one.
385        $timestamp = wp_next_scheduled( 'jetpack_heartbeat' );
386        if ( $timestamp ) {
387            wp_unschedule_event( $timestamp, 'jetpack_heartbeat' );
388        }
389
390        $timestamp = wp_next_scheduled( $this->cron_name );
391        wp_unschedule_event( $timestamp, $this->cron_name );
392    }
393
394    /**
395     * Interact with the Heartbeat
396     *
397     * ## OPTIONS
398     *
399     * inspect (default): Gets the list of data that is going to be sent in the heartbeat and the date/time of the last heartbeat
400     *
401     * @param array $args Arguments passed via CLI.
402     *
403     * @return void
404     */
405    public function cli_callback( $args ) {
406
407        $allowed_args = array(
408            'inspect',
409        );
410
411        if ( isset( $args[0] ) && ! in_array( $args[0], $allowed_args, true ) ) {
412            /* translators: %s is a command like "prompt" */
413            WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack-connection' ), $args[0] ) );
414        }
415
416        $stats           = self::generate_stats_array();
417        $formatted_stats = array();
418
419        foreach ( $stats as $stat_name => $bin ) {
420            $formatted_stats[] = array(
421                'Stat name' => $stat_name,
422                'Bin'       => $bin,
423            );
424        }
425
426        WP_CLI\Utils\format_items( 'table', $formatted_stats, array( 'Stat name', 'Bin' ) );
427
428        $last_heartbeat = Jetpack_Options::get_option( 'last_heartbeat' );
429
430        if ( $last_heartbeat ) {
431            $last_date = gmdate( 'Y-m-d H:i:s', $last_heartbeat );
432            /* translators: %s is the full datetime of the last heart beat e.g. 2020-01-01 12:21:23 */
433            WP_CLI::line( sprintf( __( 'Last heartbeat sent at: %s', 'jetpack-connection' ), $last_date ) );
434        }
435    }
436
437    /**
438     * Initialize the heartbeat REST API.
439     *
440     * @return void
441     */
442    public function initialize_rest_api() {
443        register_rest_route(
444            'jetpack/v4',
445            '/heartbeat/data',
446            array(
447                'methods'             => WP_REST_Server::READABLE,
448                'callback'            => array( $this, 'rest_heartbeat_data' ),
449                'permission_callback' => array( $this, 'rest_heartbeat_data_permission_check' ),
450                'args'                => array(
451                    'prefix' => array(
452                        'description' => __( 'Prefix to add before the stats identifiers.', 'jetpack-connection' ),
453                        'type'        => 'string',
454                    ),
455                ),
456            )
457        );
458    }
459
460    /**
461     * Endpoint to retrieve the heartbeat data.
462     *
463     * @param WP_REST_Request $request The request data.
464     *
465     * @since 2.7.0
466     *
467     * @return array
468     */
469    public function rest_heartbeat_data( WP_REST_Request $request ) {
470        return static::generate_stats_array( $request->get_param( 'prefix' ) );
471    }
472
473    /**
474     * Check permissions for the `get_heartbeat_data` endpoint.
475     *
476     * @return true|WP_Error
477     */
478    public function rest_heartbeat_data_permission_check() {
479        if ( current_user_can( 'jetpack_connect' ) ) {
480            return true;
481        }
482
483        return Rest_Authentication::is_signed_with_blog_token()
484            ? true
485            : new WP_Error( 'invalid_permission_heartbeat_data', REST_Connector::get_user_permissions_error_msg(), array( 'status' => rest_authorization_required_code() ) );
486    }
487}