rebase from live enviornment

wp/plugins/woocommerce/includes/tracks/events/class-wc-admin-setup-wizard-tracking.php

@@ -0,0 +1,176 @@
+<?php
+/**
+ * WooCommerce Admin Setup Wizard Tracking
+ *
+ * @package WooCommerce\Tracks
+ *
+ * @deprecated 4.6.0
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of the WooCommerce Onboarding Wizard.
+ */
+class WC_Admin_Setup_Wizard_Tracking {
+	/**
+	 * Steps for the setup wizard
+	 *
+	 * @var array
+	 */
+	private $steps = array();
+
+	/**
+	 * Init tracking.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function init() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Get the name of the current step.
+	 *
+	 * @deprecated 4.6.0
+	 * @return string
+	 */
+	public function get_current_step() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+		return isset( $_GET['step'] ) ? sanitize_key( $_GET['step'] ) : ''; // phpcs:ignore WordPress.Security.NonceVerification.Recommended
+	}
+
+	/**
+	 * Add footer scripts to OBW via woocommerce_setup_footer
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function add_footer_scripts() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Dequeue unwanted scripts from OBW footer.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function dequeue_non_allowed_scripts() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+		global $wp_scripts;
+		$allowed = array( 'woo-tracks' );
+
+		foreach ( $wp_scripts->queue as $script ) {
+			if ( in_array( $script, $allowed, true ) ) {
+				continue;
+			}
+			wp_dequeue_script( $script );
+		}
+	}
+
+	/**
+	 * Track when tracking is opted into and OBW has started.
+	 *
+	 * @param string $option Option name.
+	 * @param string $value  Option value.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_start( $option, $value ) {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track the marketing form on submit.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_ready_next_steps() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track various events when a step is saved.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function add_step_save_events() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track store setup and store properties on save.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_store_setup() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track payment gateways selected.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_payments() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track shipping units and whether or not labels are set.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_shipping() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track recommended plugins selected for install.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_recommended() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Tracks when Jetpack is activated through the OBW.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_jetpack_activate() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Tracks when last next_steps screen is viewed in the OBW.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_next_steps() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Track skipped steps.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function track_skip_step() {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+	}
+
+	/**
+	 * Set the OBW steps inside this class instance.
+	 *
+	 * @param array $steps Array of OBW steps.
+	 *
+	 * @deprecated 4.6.0
+	 */
+	public function set_obw_steps( $steps ) {
+		_deprecated_function( __CLASS__ . '::' . __FUNCTION__, '4.6.0', __( 'Onboarding is maintained in WooCommerce Admin.', 'woocommerce' ) );
+		$this->steps = $steps;
+
+		return $steps;
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-coupon-tracking.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * WooCommerce Coupon Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+/**
+ * This class adds actions to track usage of a WooCommerce Coupon.
+ */
+class WC_Coupon_Tracking {
+
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'woocommerce_coupon_object_updated_props', array( $this, 'track_coupon_updated' ), 10, 2 );
+	}
+
+	/**
+	 * Send a Tracks event when a coupon is updated.
+	 *
+	 * @param WC_Coupon $coupon        The coupon that has been updated.
+	 * @param Array     $updated_props The props of the coupon that have been updated.
+	 */
+	public function track_coupon_updated( $coupon, $updated_props ) {
+		$properties = array(
+			'discount_code'        => $coupon->get_code(),
+			'free_shipping'        => $coupon->get_free_shipping(),
+			'individual_use'       => $coupon->get_individual_use(),
+			'exclude_sale_items'   => $coupon->get_exclude_sale_items(),
+			'usage_limits_applied' => 0 < intval( $coupon->get_usage_limit() )
+									|| 0 < intval( $coupon->get_usage_limit_per_user() )
+									|| 0 < intval( $coupon->get_limit_usage_to_x_items() ),
+		);
+
+		WC_Tracks::record_event( 'coupon_updated', $properties );
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-coupons-tracking.php

@@ -0,0 +1,73 @@
+<?php
+/**
+ * WooCommerce Coupons Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of WooCommerce Orders.
+ */
+class WC_Coupons_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'load-edit.php', array( $this, 'tracks_coupons_events' ), 10 );
+	}
+
+	/**
+	 * Add a listener on the "Apply" button to track bulk actions.
+	 */
+	public function tracks_coupons_bulk_actions() {
+		wc_enqueue_js(
+			"
+			function onApplyBulkActions( event ) {
+				var id = event.data.id;
+				var action = $( '#' + id ).val();
+				
+				if ( action && '-1' !== action ) {
+					window.wcTracks.recordEvent( 'coupons_view_bulk_action', {
+						action: action
+					} );
+				}
+			}
+			$( '#doaction' ).on( 'click', { id: 'bulk-action-selector-top' }, onApplyBulkActions );
+			$( '#doaction2' ).on( 'click', { id: 'bulk-action-selector-bottom' }, onApplyBulkActions );
+		"
+		);
+	}
+
+	/**
+	 * Track page view events.
+	 */
+	public function tracks_coupons_events() {
+		if ( isset( $_GET['post_type'] ) && 'shop_coupon' === $_GET['post_type'] ) {
+
+			$this->tracks_coupons_bulk_actions();
+
+			WC_Tracks::record_event(
+				'coupons_view',
+				array(
+					'status' => isset( $_GET['post_status'] ) ? sanitize_text_field( wp_unslash( $_GET['post_status'] ) ) : 'all',
+				)
+			);
+
+			if ( isset( $_GET['filter_action'] ) && 'Filter' === sanitize_text_field( wp_unslash( $_GET['filter_action'] ) ) && isset( $_GET['coupon_type'] ) ) {
+				WC_Tracks::record_event(
+					'coupons_filter',
+					array(
+						'filter' => 'coupon_type',
+						'value'  => sanitize_text_field( wp_unslash( $_GET['coupon_type'] ) ),
+					)
+				);
+			}
+
+			if ( isset( $_GET['s'] ) && 0 < strlen( sanitize_text_field( wp_unslash( $_GET['s'] ) ) ) ) {
+				WC_Tracks::record_event( 'coupons_search' );
+			}
+		}
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-extensions-tracking.php

@@ -0,0 +1,125 @@
+<?php
+/**
+ * WooCommerce Extensions Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of the WooCommerce Extensions page.
+ */
+class WC_Extensions_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'load-woocommerce_page_wc-addons', array( $this, 'track_extensions_page' ) );
+		add_action( 'woocommerce_helper_connect_start', array( $this, 'track_helper_connection_start' ) );
+		add_action( 'woocommerce_helper_denied', array( $this, 'track_helper_connection_cancelled' ) );
+		add_action( 'woocommerce_helper_connected', array( $this, 'track_helper_connection_complete' ) );
+		add_action( 'woocommerce_helper_disconnected', array( $this, 'track_helper_disconnected' ) );
+		add_action( 'woocommerce_helper_subscriptions_refresh', array( $this, 'track_helper_subscriptions_refresh' ) );
+		add_action( 'woocommerce_addon_installed', array( $this, 'track_addon_install' ), 10, 2 );
+		add_action( 'woocommerce_page_wc-addons_connection_error', array( $this, 'track_extensions_page_connection_error' ), 10, 1 );
+	}
+
+	/**
+	 * Send a Tracks event when an Extensions page is viewed.
+	 */
+	public function track_extensions_page() {
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		$properties = array(
+			'section' => empty( $_REQUEST['section'] ) ? '_featured' : wc_clean( wp_unslash( $_REQUEST['section'] ) ),
+		);
+
+		$event      = 'extensions_view';
+		if ( 'helper' === $properties['section'] ) {
+			$event = 'subscriptions_view';
+		}
+
+		if ( ! empty( $_REQUEST['search'] ) ) {
+			$event                     = 'extensions_view_search';
+			$properties['search_term'] = wc_clean( wp_unslash( $_REQUEST['search'] ) );
+		}
+		// phpcs:enable
+
+		WC_Tracks::record_event( $event, $properties );
+	}
+
+	/**
+	 * Send a Tracks event when the Extensions page gets a bad response or no response
+	 * from the WCCOM extensions API.
+	 *
+	 * @param string $error
+	 */
+	public function track_extensions_page_connection_error( string $error = '' ) {
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		$properties = array(
+			'section' => empty( $_REQUEST['section'] ) ? '_featured' : wc_clean( wp_unslash( $_REQUEST['section'] ) ),
+		);
+
+		if ( ! empty( $_REQUEST['search'] ) ) {
+			$properties['search_term'] = wc_clean( wp_unslash( $_REQUEST['search'] ) );
+		}
+		// phpcs:enable
+
+		if ( ! empty( $error ) ) {
+			$properties['error_data'] = $error;
+		}
+		WC_Tracks::record_event( 'extensions_view_connection_error', $properties );
+	}
+
+	/**
+	 * Send a Tracks even when a Helper connection process is initiated.
+	 */
+	public function track_helper_connection_start() {
+		WC_Tracks::record_event( 'extensions_subscriptions_connect' );
+	}
+
+	/**
+	 * Send a Tracks even when a Helper connection process is cancelled.
+	 */
+	public function track_helper_connection_cancelled() {
+		WC_Tracks::record_event( 'extensions_subscriptions_cancelled' );
+	}
+
+	/**
+	 * Send a Tracks even when a Helper connection process completed successfully.
+	 */
+	public function track_helper_connection_complete() {
+		WC_Tracks::record_event( 'extensions_subscriptions_connected' );
+	}
+
+	/**
+	 * Send a Tracks even when a Helper has been disconnected.
+	 */
+	public function track_helper_disconnected() {
+		WC_Tracks::record_event( 'extensions_subscriptions_disconnect' );
+	}
+
+	/**
+	 * Send a Tracks even when Helper subscriptions are refreshed.
+	 */
+	public function track_helper_subscriptions_refresh() {
+		WC_Tracks::record_event( 'extensions_subscriptions_update' );
+	}
+
+	/**
+	 * Send a Tracks event when addon is installed via the Extensions page.
+	 *
+	 * @param string $addon_id Addon slug.
+	 * @param string $section  Extensions tab.
+	 */
+	public function track_addon_install( $addon_id, $section ) {
+		$properties = array(
+			'context' => 'extensions',
+			'section' => $section,
+		);
+
+		if ( 'woocommerce-payments' === $addon_id ) {
+			WC_Tracks::record_event( 'woocommerce_payments_install', $properties );
+		}
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-importer-tracking.php

@@ -0,0 +1,84 @@
+<?php
+/**
+ * WooCommerce Import Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of WooCommerce Imports.
+ */
+class WC_Importer_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'product_page_product_importer', array( $this, 'track_product_importer' ) );
+	}
+
+	/**
+	 * Route product importer action to the right callback.
+	 *
+	 * @return void
+	 */
+	public function track_product_importer() {
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		if ( ! isset( $_REQUEST['step'] ) ) {
+			return;
+		}
+
+		if ( 'import' === $_REQUEST['step'] ) {
+			return $this->track_product_importer_start();
+		}
+
+		if ( 'done' === $_REQUEST['step'] ) {
+			return $this->track_product_importer_complete();
+		}
+		// phpcs:enable
+	}
+
+	/**
+	 * Send a Tracks event when the product importer is started.
+	 *
+	 * @return void
+	 */
+	public function track_product_importer_start() {
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		if ( ! isset( $_REQUEST['file'] ) || ! isset( $_REQUEST['_wpnonce'] ) ) {
+			return;
+		}
+
+		$properties = array(
+			'update_existing' => isset( $_REQUEST['update_existing'] ) ? (bool) $_REQUEST['update_existing'] : false,
+			'delimiter'       => empty( $_REQUEST['delimiter'] ) ? ',' : wc_clean( wp_unslash( $_REQUEST['delimiter'] ) ),
+		);
+		// phpcs:enable
+
+		WC_Tracks::record_event( 'product_import_start', $properties );
+	}
+
+	/**
+	 * Send a Tracks event when the product importer has finished.
+	 *
+	 * @return void
+	 */
+	public function track_product_importer_complete() {
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		if ( ! isset( $_REQUEST['nonce'] ) ) {
+			return;
+		}
+
+		$properties = array(
+			'imported'            => isset( $_GET['products-imported'] ) ? absint( $_GET['products-imported'] ) : 0,
+			'imported_variations' => isset( $_GET['products-imported-variations'] ) ? absint( $_GET['products-imported-variations'] ) : 0,
+			'updated'             => isset( $_GET['products-updated'] ) ? absint( $_GET['products-updated'] ) : 0,
+			'failed'              => isset( $_GET['products-failed'] ) ? absint( $_GET['products-failed'] ) : 0,
+			'skipped'             => isset( $_GET['products-skipped'] ) ? absint( $_GET['products-skipped'] ) : 0,
+		);
+		// phpcs:enable
+
+		WC_Tracks::record_event( 'product_import_complete', $properties );
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-order-tracking.php

@@ -0,0 +1,40 @@
+<?php
+/**
+ * WooCommerce Order Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of a WooCommerce Order.
+ */
+class WC_Order_Tracking {
+
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'woocommerce_admin_order_data_after_order_details', array( $this, 'track_order_viewed' ) );
+	}
+
+	/**
+	 * Send a Tracks event when an order is viewed.
+	 *
+	 * @param WC_Order $order Order.
+	 */
+	public function track_order_viewed( $order ) {
+		if ( ! $order instanceof WC_Order || ! $order->get_id() ) {
+			return;
+		}
+		$properties = array(
+			'current_status' => $order->get_status(),
+			'date_created'   => $order->get_date_created() ? $order->get_date_created()->format( DateTime::ATOM ) : '',
+			'payment_method' => $order->get_payment_method(),
+		);
+
+		WC_Tracks::record_event( 'single_order_view', $properties );
+	}
+}
+

wp/plugins/woocommerce/includes/tracks/events/class-wc-orders-tracking.php

@@ -0,0 +1,196 @@
+<?php
+/**
+ * WooCommerce Orders Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+use Automattic\WooCommerce\Utilities\OrderUtil;
+use Automattic\WooCommerce\Internal\Admin\WCAdminAssets;
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of WooCommerce Orders.
+ */
+class WC_Orders_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'woocommerce_order_status_changed', array( $this, 'track_order_status_change' ), 10, 3 );
+		add_action( 'load-edit.php', array( $this, 'track_orders_view' ), 10 );
+		add_action( 'pre_post_update', array( $this, 'track_created_date_change' ), 10 );
+		// WC_Meta_Box_Order_Actions::save() hooks in at priority 50.
+		add_action( 'woocommerce_process_shop_order_meta', array( $this, 'track_order_action' ), 51 );
+		add_action( 'load-post-new.php', array( $this, 'track_add_order_from_edit' ), 10 );
+		add_filter( 'woocommerce_shop_order_search_results', array( $this, 'track_order_search' ), 10, 3 );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_order_tracking_scripts' ) );
+	}
+
+	/**
+	 * Send a track event when on the Order Listing page, and search results are being displayed.
+	 *
+	 * @param array  $order_ids Array of order_ids that are matches for the search.
+	 * @param string $term The string that was used in the search.
+	 * @param array  $search_fields Fields that were used in the original search.
+	 */
+	public function track_order_search( $order_ids, $term, $search_fields ) {
+		// Since `woocommerce_shop_order_search_results` can run in the front-end context, exit if get_current_screen isn't defined.
+		if ( ! function_exists( 'get_current_screen' ) ) {
+			return $order_ids;
+		}
+
+		$screen = get_current_screen();
+
+		// We only want to record this track when the filter is executed on the order listing page.
+		if ( 'edit-shop_order' === $screen->id ) {
+			// we are on the order listing page, and query results are being shown.
+			WC_Tracks::record_event( 'orders_view_search' );
+		}
+
+		return $order_ids;
+	}
+
+	/**
+	 * Send a Tracks event when the Orders page is viewed.
+	 */
+	public function track_orders_view() {
+		if ( isset( $_GET['post_type'] ) && 'shop_order' === wp_unslash( $_GET['post_type'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+
+			// phpcs:disable WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput
+			$properties = array(
+				'status' => isset( $_GET['post_status'] ) ? sanitize_text_field( $_GET['post_status'] ) : 'all',
+			);
+			// phpcs:enable
+
+			WC_Tracks::record_event( 'orders_view', $properties );
+		}
+	}
+
+	/**
+	 * Send a Tracks event when an order status is changed.
+	 *
+	 * @param int    $id Order id.
+	 * @param string $previous_status the old WooCommerce order status.
+	 * @param string $next_status the new WooCommerce order status.
+	 */
+	public function track_order_status_change( $id, $previous_status, $next_status ) {
+		$order = wc_get_order( $id );
+
+		$properties = array(
+			'order_id'        => $id,
+			'next_status'     => $next_status,
+			'previous_status' => $previous_status,
+			'date_created'    => $order->get_date_created() ? $order->get_date_created()->date( 'Y-m-d' ) : '',
+			'payment_method'  => $order->get_payment_method(),
+			'order_total'     => $order->get_total(),
+		);
+
+		WC_Tracks::record_event( 'orders_edit_status_change', $properties );
+	}
+
+	/**
+	 * Send a Tracks event when an order date is changed.
+	 *
+	 * @param int $id Order id.
+	 */
+	public function track_created_date_change( $id ) {
+		if ( ! OrderUtil::is_order( $id ) ) {
+			return;
+		}
+
+		if ( 'auto-draft' === get_post_status( $id ) ) {
+			return;
+		}
+
+		$order        = wc_get_order( $id );
+		$date_created = $order->get_date_created() ? $order->get_date_created()->date( 'Y-m-d H:i:s' ) : '';
+		// phpcs:disable WordPress.Security.NonceVerification
+		$new_date = sprintf(
+			'%s %2d:%2d:%2d',
+			isset( $_POST['order_date'] ) ? wc_clean( wp_unslash( $_POST['order_date'] ) ) : '',
+			isset( $_POST['order_date_hour'] ) ? wc_clean( wp_unslash( $_POST['order_date_hour'] ) ) : '',
+			isset( $_POST['order_date_minute'] ) ? wc_clean( wp_unslash( $_POST['order_date_minute'] ) ) : '',
+			isset( $_POST['order_date_second'] ) ? wc_clean( wp_unslash( $_POST['order_date_second'] ) ) : ''
+		);
+		// phpcs:enable
+
+		if ( $new_date !== $date_created ) {
+			$properties = array(
+				'order_id' => $id,
+				'status'   => $order->get_status(),
+			);
+
+			WC_Tracks::record_event( 'order_edit_date_created', $properties );
+		}
+	}
+
+	/**
+	 * Track order actions taken.
+	 *
+	 * @param int $order_id Order ID.
+	 */
+	public function track_order_action( $order_id ) {
+		// phpcs:disable WordPress.Security.NonceVerification
+		if ( ! empty( $_POST['wc_order_action'] ) ) {
+			$order      = wc_get_order( $order_id );
+			$action     = wc_clean( wp_unslash( $_POST['wc_order_action'] ) );
+			$properties = array(
+				'order_id' => $order_id,
+				'status'   => $order->get_status(),
+				'action'   => $action,
+			);
+
+			WC_Tracks::record_event( 'order_edit_order_action', $properties );
+		}
+		// phpcs:enable
+	}
+
+	/**
+	 * Track "add order" button on the Edit Order screen.
+	 */
+	public function track_add_order_from_edit() {
+		// phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+		if ( isset( $_GET['post_type'] ) && 'shop_order' === wp_unslash( $_GET['post_type'] ) ) {
+			$referer = wp_get_referer();
+
+			if ( $referer ) {
+				$referring_page = wp_parse_url( $referer );
+				$referring_args = array();
+				$post_edit_page = wp_parse_url( admin_url( 'post.php' ) );
+
+				if ( ! empty( $referring_page['query'] ) ) {
+					parse_str( $referring_page['query'], $referring_args );
+				}
+
+				// Determine if we arrived from an Order Edit screen.
+				if (
+					$post_edit_page['path'] === $referring_page['path'] &&
+					isset( $referring_args['action'] ) &&
+					'edit' === $referring_args['action'] &&
+					isset( $referring_args['post'] ) &&
+					'shop_order' === OrderUtil::get_order_type( $referring_args['post'] )
+				) {
+					WC_Tracks::record_event( 'order_edit_add_order' );
+				}
+			}
+		}
+	}
+
+	/**
+	 * Adds the tracking scripts for product setting pages.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_order_tracking_scripts( $hook ) {
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			( isset( $_GET['post_type'] ) && 'shop_order' === wp_unslash( $_GET['post_type'] ) ) ||
+			( 'post.php' === $hook && isset( $_GET['post'] ) && 'shop_order' === get_post_type( intval( $_GET['post'] ) ) )
+		) {
+			WCAdminAssets::register_script( 'wp-admin-scripts', 'order-tracking', false );
+		}
+		// phpcs:enable
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-products-tracking.php

@@ -0,0 +1,539 @@
+<?php
+/**
+ * WooCommerce Import Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+use Automattic\Jetpack\Constants;
+use Automattic\WooCommerce\Internal\Admin\WCAdminAssets;
+
+defined( 'ABSPATH' ) || exit;
+
+require_once WC_ABSPATH . 'includes/admin/wc-admin-functions.php';
+
+/**
+ * This class adds actions to track usage of WooCommerce Products.
+ */
+class WC_Products_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'load-edit.php', array( $this, 'track_products_view' ), 10 );
+		add_action( 'load-edit-tags.php', array( $this, 'track_categories_and_tags_view' ), 10, 2 );
+		add_action( 'edit_post', array( $this, 'track_product_updated' ), 10, 2 );
+		add_action( 'wp_after_insert_post', array( $this, 'track_product_published' ), 10, 4 );
+		add_action( 'created_product_cat', array( $this, 'track_product_category_created' ) );
+		add_action( 'edited_product_cat', array( $this, 'track_product_category_updated' ) );
+		add_action( 'add_meta_boxes_product', array( $this, 'track_product_updated_client_side' ), 10 );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_product_tracking_scripts' ) );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_product_import_scripts' ) );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_attribute_tracking_scripts' ) );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_tag_tracking_scripts' ) );
+	}
+
+	/**
+	 * Send a Tracks event when the Products page is viewed.
+	 */
+	public function track_products_view() {
+		// We only record Tracks event when no `_wp_http_referer` query arg is set, since
+		// when searching, the request gets sent from the browser twice,
+		// once with the `_wp_http_referer` and once without it.
+		//
+		// Otherwise, we would double-record the view and search events.
+
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			isset( $_GET['post_type'] )
+			&& 'product' === wp_unslash( $_GET['post_type'] )
+			&& ! isset( $_GET['_wp_http_referer'] )
+		) {
+			// phpcs:enable
+
+			WC_Tracks::record_event( 'products_view' );
+
+			// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+			if (
+				isset( $_GET['s'] )
+				&& 0 < strlen( sanitize_text_field( wp_unslash( $_GET['s'] ) ) )
+			) {
+				// phpcs:enable
+
+				WC_Tracks::record_event( 'products_search' );
+			}
+		}
+	}
+
+	/**
+	 * Send a Tracks event when the Products Categories and Tags page is viewed.
+	 */
+	public function track_categories_and_tags_view() {
+		// We only record Tracks event when no `_wp_http_referer` query arg is set, since
+		// when searching, the request gets sent from the browser twice,
+		// once with the `_wp_http_referer` and once without it.
+		//
+		// Otherwise, we would double-record the view and search events.
+
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			isset( $_GET['post_type'] )
+			&& 'product' === wp_unslash( $_GET['post_type'] )
+			&& isset( $_GET['taxonomy'] )
+			&& ! isset( $_GET['_wp_http_referer'] )
+		) {
+			$taxonomy = wp_unslash( $_GET['taxonomy'] );
+			// phpcs:enable
+
+			if ( 'product_cat' === $taxonomy ) {
+				WC_Tracks::record_event( 'categories_view' );
+			} elseif ( 'product_tag' === $taxonomy ) {
+				WC_Tracks::record_event( 'tags_view' );
+			}
+
+			// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+			if (
+				isset( $_GET['s'] )
+				&& 0 < strlen( sanitize_text_field( wp_unslash( $_GET['s'] ) ) )
+			) {
+				// phpcs:enable
+
+				if ( 'product_cat' === $taxonomy ) {
+					WC_Tracks::record_event( 'categories_search' );
+				} elseif ( 'product_tag' === $taxonomy ) {
+					WC_Tracks::record_event( 'tags_search' );
+				}
+			}
+		}
+	}
+
+	/**
+	 * Send a Tracks event when a product is updated.
+	 *
+	 * @param int    $product_id Product id.
+	 * @param object $post       WordPress post.
+	 */
+	public function track_product_updated( $product_id, $post ) {
+		if ( 'product' !== $post->post_type ) {
+			return;
+		}
+
+		$properties = array(
+			'product_id' => $product_id,
+		);
+
+		WC_Tracks::record_event( 'product_edit', $properties );
+	}
+
+	/**
+	 * Track the Update button being clicked on the client side.
+	 * This is needed because `track_product_updated` (using the `edit_post`
+	 * hook) is called in response to a number of other triggers.
+	 *
+	 * @param WP_Post $post The post, not used.
+	 */
+	public function track_product_updated_client_side( $post ) {
+		wc_enqueue_js(
+			"
+			if ( $( 'h1.wp-heading-inline' ).text().trim() === '" . __( 'Edit product', 'woocommerce' ) . "') {
+				var initialStockValue = $( '#_stock' ).val();
+				var isBlockEditor = false;
+				var child_element = '#publish';
+
+				if ( $( '.block-editor' ).length !== 0 && $( '.block-editor' )[0] ) {
+	    			isBlockEditor = true;
+				}
+
+				if ( isBlockEditor ) {
+					child_element = '.editor-post-publish-button';
+				}
+
+				$( '#wpwrap' ).on( 'click', child_element, function() {
+					var description_value  = '';
+					var tagsText = '';
+					var currentStockValue = $( '#_stock' ).val();
+
+					function getProductTypeOptions() {
+						const productTypeOptionsCheckboxes = $( 'input[type=\"checkbox\"][data-product-type-option-id]' );
+						const productTypeOptions = productTypeOptionsCheckboxes.map( function() {
+							return {
+								id: $( this ).data( 'product-type-option-id' ),
+								isEnabled: $( this ).is( ':checked' ),
+							};
+						} ).get();
+						return productTypeOptions;
+					}
+
+					function getProductTypeOptionsString( productTypeOptions ) {
+						return productTypeOptions
+							.filter( productTypeOption => productTypeOption.isEnabled )
+							.map( productTypeOption => productTypeOption.id )
+							.join( ', ' );
+					}
+
+					const productTypeOptions = getProductTypeOptions();
+					const productTypeOptionsString = getProductTypeOptionsString( productTypeOptions );
+
+					if ( ! isBlockEditor ) {
+						tagsText          = $( '[name=\"tax_input[product_tag]\"]' ).val();
+						if ( $( '#content' ).is( ':visible' ) ) {
+							description_value = $( '#content' ).val();
+						} else if ( typeof tinymce === 'object' && tinymce.get( 'content' ) ) {
+							description_value = tinymce.get( 'content' ).getContent();
+						}
+					} else {
+						description_value  = $( '.block-editor-rich-text__editable' ).text();
+					}
+
+					// We can't just check the number of '.woocommerce_attribute' elements because
+					// there might be empty ones, which get stripped out when saved. So, we'll check
+					// whether the name and values have been filled out.
+					var numberOfAttributes = $( '.woocommerce_attribute' ).filter( function () {
+						var attributeElement = $( this );
+						var attributeName = attributeElement.find( 'input.attribute_name' ).val();
+						var attributeValues = attributeElement.find( 'textarea[name^=\"attribute_values\"]' ).val();
+
+						return attributeName !== '' && attributeValues !== '';
+					} ).length;
+
+					var properties = {
+						attributes:				     numberOfAttributes,
+						categories:				     $( '[name=\"tax_input[product_cat][]\"]:checked' ).length,
+						cross_sells:			     $( '#crosssell_ids option' ).length ? 'Yes' : 'No',
+						description:			     description_value.trim() !== '' ? 'Yes' : 'No',
+						enable_reviews:			     $( '#comment_status' ).is( ':checked' ) ? 'Yes' : 'No',
+						is_virtual:				     $( '#_virtual' ).is( ':checked' ) ? 'Yes' : 'No',
+						is_block_editor:		     isBlockEditor,
+						is_downloadable:		     $( '#_downloadable' ).is( ':checked' ) ? 'Yes' : 'No',
+						manage_stock:			     $( '#_manage_stock' ).is( ':checked' ) ? 'Yes' : 'No',
+						menu_order:				     parseInt( $( '#menu_order' ).val(), 10 ) !== 0 ? 'Yes' : 'No',
+						product_gallery:		     $( '#product_images_container .product_images > li' ).length,
+						product_image:			     $( '#_thumbnail_id' ).val() > 0 ? 'Yes' : 'No',
+						product_type:			     $( '#product-type' ).val(),
+						product_type_options_string: productTypeOptionsString,
+						purchase_note:			     $( '#_purchase_note' ).val().length ? 'yes' : 'no',
+						sale_price:				     $( '#_sale_price' ).val() ? 'yes' : 'no',
+						short_description:		     $( '#excerpt' ).val().length ? 'yes' : 'no',
+						stock_quantity_update:	     ( initialStockValue != currentStockValue ) ? 'Yes' : 'No',
+						tags:					     tagsText.length > 0 ? tagsText.split( ',' ).length : 0,
+						upsells:				     $( '#upsell_ids option' ).length ? 'Yes' : 'No',
+						weight:					     $( '#_weight' ).val() ? 'Yes' : 'No',
+					};
+					window.wcTracks.recordEvent( 'product_update', properties );
+				} );
+			}
+			"
+		);
+	}
+
+	/**
+	 * Get the IDs of the possible product type options.
+	 *
+	 * @return array
+	 */
+	private static function get_possible_product_type_options_ids() {
+		$product_type_options_ids =
+			array_values(
+				array_map(
+					function ( $product_type_option ) {
+						return $product_type_option['id'];
+					},
+					/* phpcs:disable WooCommerce.Commenting.CommentHooks.MissingHookComment */
+					apply_filters(
+						'product_type_options',
+						wc_get_default_product_type_options(),
+					)
+					/* phpcs: enable */
+				)
+			);
+
+		return $product_type_options_ids;
+	}
+
+	/**
+	 * Get the product type options for a product.
+	 *
+	 * @param int $post_id The ID of the product.
+	 *
+	 * @return array
+	 */
+	private static function get_product_type_options( $post_id ) {
+		$possible_product_type_options_ids = self::get_possible_product_type_options_ids();
+		$post_meta                         = get_post_meta( $post_id );
+		$product_type_options              = array();
+
+		foreach ( $possible_product_type_options_ids as $product_type_option_id ) {
+			$product_type_options[ $product_type_option_id ] = isset( $post_meta[ $product_type_option_id ] ) ? $post_meta[ $product_type_option_id ][0] : 'no';
+		}
+
+		return $product_type_options;
+	}
+
+	/**
+	 * Get a comma-separated string of the product type options that are enabled.
+	 *
+	 * @param array $product_type_options The product type options.
+	 *
+	 * @return string
+	 */
+	private static function get_product_type_options_string( $product_type_options ) {
+		return implode(
+			', ',
+			array_keys(
+				array_filter(
+					$product_type_options,
+					function ( $is_enabled ) {
+						return 'yes' === $is_enabled;
+					}
+				)
+			)
+		);
+	}
+
+	/**
+	 * Send a Tracks event when a product is published.
+	 *
+	 * @param int          $post_id     Post ID.
+	 * @param WP_Post      $post        Post object.
+	 * @param bool         $update      Whether this is an existing post being updated.
+	 * @param null|WP_Post $post_before Null for new posts, the WP_Post object prior
+	 *                                  to the update for updated posts.
+	 */
+	public function track_product_published( $post_id, $post, $update, $post_before ) {
+		if (
+			'product' !== $post->post_type ||
+			'publish' !== $post->post_status ||
+			( $post_before && 'publish' === $post_before->post_status )
+		) {
+			return;
+		}
+
+		$product = wc_get_product( $post_id );
+
+		$product_type_options        = self::get_product_type_options( $post_id );
+		$product_type_options_string = self::get_product_type_options_string( $product_type_options );
+
+		$properties = array(
+			'attributes'           => count( $product->get_attributes() ),
+			'categories'           => count( $product->get_category_ids() ),
+			'cross_sells'          => ! empty( $product->get_cross_sell_ids() ) ? 'yes' : 'no',
+			'description'          => $product->get_description() ? 'yes' : 'no',
+			'dimensions'           => wc_format_dimensions( $product->get_dimensions( false ) ) !== 'N/A' ? 'yes' : 'no',
+			'enable_reviews'       => $product->get_reviews_allowed() ? 'yes' : 'no',
+			'is_downloadable'      => $product->is_downloadable() ? 'yes' : 'no',
+			'is_virtual'           => $product->is_virtual() ? 'yes' : 'no',
+			'manage_stock'         => $product->get_manage_stock() ? 'yes' : 'no',
+			'menu_order'           => $product->get_menu_order() ? 'yes' : 'no',
+			'product_id'           => $post_id,
+			'product_gallery'      => count( $product->get_gallery_image_ids() ),
+			'product_image'        => $product->get_image_id() ? 'yes' : 'no',
+			'product_type'         => $product->get_type(),
+			'product_type_options' => $product_type_options_string,
+			'purchase_note'        => $product->get_purchase_note() ? 'yes' : 'no',
+			'sale_price'           => $product->get_sale_price() ? 'yes' : 'no',
+			'source'               => apply_filters( 'woocommerce_product_source', '' ),
+			'short_description'    => $product->get_short_description() ? 'yes' : 'no',
+			'tags'                 => count( $product->get_tag_ids() ),
+			'upsells'              => ! empty( $product->get_upsell_ids() ) ? 'yes' : 'no',
+			'weight'               => $product->get_weight() ? 'yes' : 'no',
+		);
+
+		WC_Tracks::record_event( 'product_add_publish', $properties );
+	}
+
+	/**
+	 * Send a Tracks event when a product category is created.
+	 *
+	 * @param int $category_id Category ID.
+	 */
+	public function track_product_category_created( $category_id ) {
+		// phpcs:disable WordPress.Security.NonceVerification.Missing, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+		// Only track category creation from the edit product screen or the
+		// category management screen (which both occur via AJAX).
+		if (
+			! Constants::is_defined( 'DOING_AJAX' ) ||
+			empty( $_POST['action'] ) ||
+			(
+				// Product Categories screen.
+				'add-tag' !== $_POST['action'] &&
+				// Edit Product screen.
+				'add-product_cat' !== $_POST['action']
+			)
+		) {
+			return;
+		}
+
+		$category        = get_term( $category_id, 'product_cat' );
+		$parent_category = $category->parent > 0 ? 'Other' : 'None';
+		if ( $category->parent > 0 ) {
+			$parent = get_term( $category_id, 'product_cat' );
+			if ( 'uncategorized' === $parent->name ) {
+				$parent_category = 'Uncategorized';
+			}
+		}
+		$properties = array(
+			'category_id'     => $category_id,
+			'parent_id'       => $category->parent,
+			'parent_category' => $parent_category,
+			'page'            => ( 'add-tag' === $_POST['action'] ) ? 'categories' : 'product',
+			'display_type'    => isset( $_POST['display_type'] ) ? wp_unslash( $_POST['display_type'] ) : '',
+			'image'           => isset( $_POST['product_cat_thumbnail_id'] ) && '' !== $_POST['product_cat_thumbnail_id'] ? 'Yes' : 'No',
+		);
+		// phpcs:enable
+
+		WC_Tracks::record_event( 'product_category_add', $properties );
+	}
+
+	/**
+	 * Send a Tracks event when a product category is updated.
+	 *
+	 * @param int $category_id Category ID.
+	 */
+	public function track_product_category_updated( $category_id ) {
+		// phpcs:disable WordPress.Security.NonceVerification.Missing
+		// Only track category creation from the edit product screen or the
+		// category management screen (which both occur via AJAX).
+		if (
+			empty( $_POST['action'] ) ||
+			( 'editedtag' !== $_POST['action'] && 'inline-save-tax' !== $_POST['action'] )
+		) {
+			return;
+		}
+		// phpcs:enable
+
+		WC_Tracks::record_event( 'product_category_update' );
+	}
+
+	/**
+	 * Adds the tracking scripts for product filtering actions.
+	 *
+	 * @param string $hook Hook of the current page.
+	 * @return string|boolean
+	 */
+	protected function get_product_screen( $hook ) {
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			'edit.php' === $hook &&
+			isset( $_GET['post_type'] ) &&
+			'product' === wp_unslash( $_GET['post_type'] )
+		) {
+			return 'list';
+		}
+
+		if (
+			'post-new.php' === $hook &&
+			isset( $_GET['post_type'] ) &&
+			'product' === wp_unslash( $_GET['post_type'] )
+		) {
+			return 'new';
+		}
+
+		if (
+			'post.php' === $hook &&
+			isset( $_GET['post'] ) &&
+			'product' === get_post_type( intval( $_GET['post'] ) )
+		) {
+			return 'edit';
+		}
+
+		if ( 'product_page_product_importer' === $hook ) {
+			return 'import';
+		}
+
+		// phpcs:enable
+
+		return false;
+	}
+
+	/**
+	 * Adds the tracking scripts for product filtering actions.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_product_tracking_scripts( $hook ) {
+		$product_screen = $this->get_product_screen( $hook );
+		if ( ! $product_screen ) {
+			return;
+		}
+
+		WCAdminAssets::register_script( 'wp-admin-scripts', 'product-tracking', false );
+		wp_localize_script(
+			'wc-admin-product-tracking',
+			'productScreen',
+			array(
+				'name' => $product_screen,
+			)
+		);
+	}
+
+	/**
+	 * Adds the tracking scripts for product setting pages.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_product_import_scripts( $hook ) {
+		$product_screen = $this->get_product_screen( $hook );
+
+		if ( 'import' !== $product_screen ) {
+			return;
+		}
+
+		WCAdminAssets::register_script( 'wp-admin-scripts', 'product-import-tracking', false );
+
+	}
+
+	/**
+	 * Adds the tracking scripts for product attributes filtering actions.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_attribute_tracking_scripts( $hook ) {
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			'product_page_product_attributes' !== $hook ||
+			! isset( $_GET['page'] ) ||
+			'product_attributes' !== wp_unslash( $_GET['page'] )
+		) {
+			return;
+		}
+		// phpcs:enable
+
+		WCAdminAssets::register_script( 'wp-admin-scripts', 'attributes-tracking', false );
+	}
+
+	/**
+	 * Adds the tracking scripts for tags and categories filtering actions.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_tag_tracking_scripts( $hook ) {
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			'edit-tags.php' !== $hook ||
+			! isset( $_GET['post_type'] ) ||
+			'product' !== wp_unslash( $_GET['post_type'] )
+		) {
+			return;
+		}
+		// phpcs:enable
+
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+		if (
+			isset( $_GET['taxonomy'] ) &&
+			'product_tag' === wp_unslash( $_GET['taxonomy'] )
+		) {
+			WCAdminAssets::register_script( 'wp-admin-scripts', 'tags-tracking', false );
+			return;
+		}
+
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+		if (
+			isset( $_GET['taxonomy'] ) &&
+			'product_cat' === wp_unslash( $_GET['taxonomy'] )
+		) {
+			WCAdminAssets::register_script( 'wp-admin-scripts', 'category-tracking', false );
+			return;
+		}
+		WCAdminAssets::register_script( 'wp-admin-scripts', 'add-term-tracking', false );
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-settings-tracking.php

@@ -0,0 +1,244 @@
+<?php
+/**
+ * WooCommerce Settings Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+use Automattic\WooCommerce\Internal\Admin\WCAdminAssets;
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of WooCommerce Settings.
+ */
+class WC_Settings_Tracking {
+
+	/**
+	 * List of allowed WooCommerce settings to potentially track updates for.
+	 *
+	 * @var array
+	 */
+	protected $allowed_options = array();
+
+	/**
+	 * WooCommerce settings that have been updated (and will be tracked).
+	 *
+	 * @var array
+	 */
+	protected $updated_options = array();
+
+	/**
+	 * List of option names that are dropdown menus.
+	 *
+	 * @var array
+	 */
+	protected $dropdown_menu_options = array();
+
+
+	/**
+	 * List of options that have been modified.
+	 *
+	 * @var array
+	 */
+	protected $modified_options = array();
+
+	/**
+	 * List of options that have been deleted.
+	 *
+	 * @var array
+	 */
+	protected $deleted_options = array();
+
+	/**
+	 * List of options that have been added.
+	 *
+	 * @var array
+	 */
+	protected $added_options = array();
+
+
+	/**
+	 * Toggled options.
+	 *
+	 * @var array
+	 */
+	protected $toggled_options = array(
+		'enabled'  => array(),
+		'disabled' => array(),
+	);
+
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'woocommerce_settings_page_init', array( $this, 'track_settings_page_view' ) );
+		add_action( 'woocommerce_update_option', array( $this, 'add_option_to_list' ) );
+		add_action( 'woocommerce_update_non_option_setting', array( $this, 'add_option_to_list_and_track_setting_change' ) );
+		add_action( 'woocommerce_update_options', array( $this, 'send_settings_change_event' ) );
+		add_action( 'admin_enqueue_scripts', array( $this, 'possibly_add_settings_tracking_scripts' ) );
+	}
+
+	/**
+	 * Adds the option to the allowed and updated options directly.
+	 * Currently used for settings that don't use update_option.
+	 *
+	 * @param array $option WooCommerce option that should be updated.
+	 */
+	public function add_option_to_list_and_track_setting_change( $option ) {
+		if ( ! in_array( $option['id'], $this->allowed_options, true ) ) {
+			$this->allowed_options[] = $option['id'];
+		}
+		if ( isset( $option['action'] ) ) {
+			if ( 'add' === $option['action'] ) {
+				$this->added_options[] = $option['id'];
+			} elseif ( 'delete' === $option['action'] ) {
+				$this->deleted_options[] = $option['id'];
+			} elseif ( ! in_array( $option['id'], $this->updated_options, true ) ) {
+				$this->updated_options[] = $option['id'];
+			}
+		} elseif ( isset( $option['value'] ) ) {
+			if ( 'select' === $option['type'] ) {
+				$this->modified_options[ $option['id'] ] = $option['value'];
+
+			} elseif ( 'checkbox' === $option['type'] ) {
+				$option_state                             = 'yes' === $option['value'] ? 'enabled' : 'disabled';
+				$this->toggled_options[ $option_state ][] = $option['id'];
+			}
+			$this->updated_options[] = $option['id'];
+		}
+
+	}
+
+	/**
+	 * Add a WooCommerce option name to our allowed options list and attach
+	 * the `update_option` hook. Rather than inspecting every updated
+	 * option and pattern matching for "woocommerce", just build a dynamic
+	 * list for WooCommerce options that might get updated.
+	 *
+	 * See `woocommerce_update_option` hook.
+	 *
+	 * @param array $option WooCommerce option (config) that might get updated.
+	 */
+	public function add_option_to_list( $option ) {
+		$this->allowed_options[] = $option['id'];
+
+		if ( isset( $option['options'] ) ) {
+			$this->dropdown_menu_options[] = $option['id'];
+		}
+
+		// Delay attaching this action since it could get fired a lot.
+		if ( false === has_action( 'update_option', array( $this, 'track_setting_change' ) ) ) {
+			add_action( 'update_option', array( $this, 'track_setting_change' ), 10, 3 );
+		}
+	}
+
+	/**
+	 * Add WooCommerce option to a list of updated options.
+	 *
+	 * @param string $option_name Option being updated.
+	 * @param mixed  $old_value Old value of option.
+	 * @param mixed  $new_value New value of option.
+	 */
+	public function track_setting_change( $option_name, $old_value, $new_value ) {
+		// Make sure this is a WooCommerce option.
+		if ( ! in_array( $option_name, $this->allowed_options, true ) ) {
+			return;
+		}
+
+		// Check to make sure the new value is truly different.
+		// `woocommerce_price_num_decimals` tends to trigger this
+		// because form values aren't coerced (e.g. '2' vs. 2).
+		if (
+			is_scalar( $old_value ) &&
+			is_scalar( $new_value ) &&
+			(string) $old_value === (string) $new_value
+		) {
+			return;
+		}
+
+		if ( in_array( $option_name, $this->dropdown_menu_options, true ) ) {
+			$this->modified_options[ $option_name ] = $new_value;
+		} elseif ( in_array( $new_value, array( 'yes', 'no' ), true ) && in_array( $old_value, array( 'yes', 'no' ), true ) ) {
+			// Save toggled options.
+			$option_state                             = 'yes' === $new_value ? 'enabled' : 'disabled';
+			$this->toggled_options[ $option_state ][] = $option_name;
+		}
+
+		$this->updated_options[] = $option_name;
+	}
+
+	/**
+	 * Send a Tracks event for WooCommerce options that changed values.
+	 */
+	public function send_settings_change_event() {
+		global $current_tab, $current_section;
+
+		if ( empty( $this->updated_options ) && empty( $this->deleted_options ) && empty( $this->added_options ) ) {
+			return;
+		}
+
+		$properties = array();
+
+		if ( ! empty( $this->updated_options ) ) {
+			$properties['settings'] = implode( ',', $this->updated_options );
+		}
+
+		if ( ! empty( $this->deleted_options ) ) {
+			$properties['deleted'] = implode( ',', $this->deleted_options );
+		}
+
+		if ( ! empty( $this->added_options ) ) {
+			$properties['added'] = implode( ',', $this->added_options );
+		}
+
+		foreach ( $this->toggled_options as $state => $options ) {
+			if ( ! empty( $options ) ) {
+				$properties[ $state ] = implode( ',', $options );
+			}
+		}
+
+		if ( ! empty( $this->modified_options ) ) {
+			foreach ( $this->modified_options as $option_name => $selected_option ) {
+				$properties[ $option_name ] = $selected_option ?? '';
+			}
+		}
+
+		$properties['tab']     = $current_tab ?? '';
+		$properties['section'] = $current_section ?? '';
+
+		WC_Tracks::record_event( 'settings_change', $properties );
+	}
+
+	/**
+	 * Send a Tracks event for WooCommerce settings page views.
+	 */
+	public function track_settings_page_view() {
+		global $current_tab, $current_section;
+
+		$properties = array(
+			'tab'     => $current_tab,
+			'section' => empty( $current_section ) ? null : $current_section,
+		);
+
+		WC_Tracks::record_event( 'settings_view', $properties );
+	}
+
+	/**
+	 * Adds the tracking scripts for product setting pages.
+	 *
+	 * @param string $hook Page hook.
+	 */
+	public function possibly_add_settings_tracking_scripts( $hook ) {
+		// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.NonceVerification
+		if (
+			! isset( $_GET['page'] ) ||
+			'wc-settings' !== wp_unslash( $_GET['page'] )
+		) {
+			return;
+		}
+		// phpcs:enable
+
+		WCAdminAssets::register_script( 'wp-admin-scripts', 'settings-tracking', false );
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-status-tracking.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * WooCommerce Status Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of WooCommerce Orders.
+ */
+class WC_Status_Tracking {
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		add_action( 'admin_init', array( $this, 'track_status_view' ), 10 );
+	}
+
+	/**
+	 * Add Tracks events to the status page.
+	 */
+	public function track_status_view() {
+		if ( isset( $_GET['page'] ) && 'wc-status' === sanitize_text_field( wp_unslash( $_GET['page'] ) ) ) {
+
+			$tab = isset( $_GET['tab'] ) ? sanitize_text_field( wp_unslash( $_GET['tab'] ) ) : 'status';
+
+			WC_Tracks::record_event(
+				'status_view',
+				array(
+					'tab'       => $tab,
+					'tool_used' => isset( $_GET['action'] ) ? sanitize_text_field( wp_unslash( $_GET['action'] ) ) : null,
+				)
+			);
+
+			if ( 'status' === $tab ) {
+				wc_enqueue_js(
+					"
+					$( 'a.debug-report' ).on( 'click', function() {
+						window.wcTracks.recordEvent( 'status_view_reports' );
+					} );
+				"
+				);
+			}
+		}
+	}
+}

wp/plugins/woocommerce/includes/tracks/events/class-wc-theme-tracking.php

@@ -0,0 +1,56 @@
+<?php
+/**
+ * WooCommerce Theme Tracking
+ *
+ * @package WooCommerce\Tracks
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * This class adds actions to track usage of themes on a WooCommerce store.
+ */
+class WC_Theme_Tracking {
+
+	/**
+	 * Init tracking.
+	 */
+	public function init() {
+		$this->track_initial_theme();
+		add_action( 'switch_theme', array( $this, 'track_activated_theme' ) );
+	}
+
+	/**
+	 * Tracks the sites current theme the first time this code is run, and will only be run once.
+	 */
+	public function track_initial_theme() {
+		$has_been_initially_tracked = get_option( 'wc_has_tracked_default_theme' );
+
+		if ( $has_been_initially_tracked ) {
+			return;
+		}
+
+		$this->track_activated_theme();
+		add_option( 'wc_has_tracked_default_theme', 1 );
+	}
+
+	/**
+	 * Send a Tracks event when a theme is activated so that we can track active block themes.
+	 */
+	public function track_activated_theme() {
+		$is_block_theme = false;
+		$theme_object = wp_get_theme();
+
+		if ( function_exists( 'wc_current_theme_is_fse_theme' ) ) {
+			$is_block_theme = wc_current_theme_is_fse_theme();
+		}
+
+		$properties = array(
+			'block_theme'   => $is_block_theme,
+			'theme_name'    => $theme_object->get( 'Name' ),
+			'theme_version' => $theme_object->get( 'Version' ),
+		);
+
+		WC_Tracks::record_event( 'activated_theme', $properties );
+	}
+}