<?php
/**
 * File: Extension_NewRelic_Service.php
 *
 * @package W3TC
 */

namespace W3TC;

/**
 * Class Extension_NewRelic_Service
 *
 * Wrapper for NewRelicAPI.
 * deprecated
 *
 * @see NewRelicAPI
 * @link https://docs.newrelic.com/docs/apis/rest-api-v2/get-started/introduction-new-relic-rest-api-v2/
 *
 * phpcs:disable PSR2.Classes.PropertyDeclaration.Underscore
 * phpcs:disable PSR2.Methods.MethodDeclaration.Underscore
 * phpcs:disable WordPress.PHP.NoSilencedErrors.Discouraged
 */
class Extension_NewRelic_Service {
	/**
	 * API key
	 *
	 * @var string
	 */
	private $_api_key;

	/**
	 * Cache time
	 *
	 * @var int
	 */
	private $_cache_time;

	/**
	 * Constructor for initializing the New Relic service.
	 *
	 * @param string $api_key Optional API key to override the default configuration.
	 *
	 * @return void
	 */
	public function __construct( $api_key = '' ) {
		$config = Dispatcher::config();
		if ( $api_key ) {
			$this->_api_key = $api_key;
		} else {
			$this->_api_key = $config->get_string( array( 'newrelic', 'api_key' ) );
		}

		$this->_cache_time = $config->get_integer( array( 'newrelic', 'cache_time' ), 5 );
		if ( $this->_cache_time < 1 ) {
			$this->_cache_time = 5;
		}
	}

	/**
	 * Verifies compatibility with the New Relic PHP agent.
	 *
	 * The verifications is based on https://newrelic.com/docs/php/new-relic-for-php
	 *
	 * @return array Associative array of verification results with status messages.
	 */
	public function verify_compatibility() {
		$php_versions   = array( '5.2.x', '5.3.x', '5.4.x' );
		$verified       = array();
		$version        = explode( '.', PHP_VERSION );
		$php_version    = sprintf( '%s.%s.%s', $version[0], $version[1], $version[2] );
		$php_version_ok = version_compare( $php_version, '5.2', '>' );

		$supported_string = __( 'Supported', 'w3-total-cache' );

		$verified[ __( 'PHP version', 'w3-total-cache' ) ] = (
			$php_version_ok ? $supported_string : sprintf(
				// Translators: 1 PHP version.
				__(
					'Not supported: %1$s.',
					'w3-total-cache'
				),
				$php_version
			)
		);

		$os_name = php_uname( 's' );
		switch ( $os_name ) {
			case 'Linux':
				/**
				 * Any other version of Linux with kernel 2.6.13 or later
				 * (2.6.26 and later highly recommended) and glibc 2.5 or later
				 */
				$version    = explode( '.', php_uname( 'r' ) );
				$os_version = sprintf( '%d.%d.%d', $version[0], $version[1], $version[2] );
				$os_check   = version_compare( $os_version, '2.6.13', '>=' );
				break;
			case 'FreeBSD':
				/**
				 * You must enable the linkthr build option so that the New Relic agent will not cause your PHP to hang.
				 */
				$version    = explode( '.', php_uname( 'r' ) );
				$os_version = sprintf( '%d.%d', $version[0], $version[1] );
				$os_check   = version_compare( $os_version, '7.3', '>=' );
				break;
			case 'MacOS/X':
				/**
				 * MacOS/X configurations do not use the standard /etc/init.d/newrelic-daemon script.
				 * Instead, they use /usr/bin/newrelic-daemon-service in the same way; for example:
				 * /usr/bin/newrelic-daemon-service restart.
				 */
				$version    = explode( '.', php_uname( 'r' ) );
				$os_version = sprintf( '%d.%d', $version[0], $version[1] );
				$os_check   = version_compare( $os_version, '10.5', '>=' );
				break;
			case 'Open Solaris':
				/**
				 * Must be snv_134b or later
				 */
				$version    = explode( '.', php_uname( 'r' ) );
				$os_version = sprintf( '%d', $version[0] );
				$os_check   = version_compare( $os_version, '10', '==' );
				break;
			default:
				$os_check   = false;
				$os_name    = php_uname();
				$os_version = '';
		}

		$verified[ __( 'Operating System', 'w3-total-cache' ) ] = ( $os_check ) ?
			$supported_string :
			sprintf(
				// translators: 1 OS name, 2 OS version, 3 opening HTML a tag to NewRelic for PHP requirments, 4 closing HTML a tag.
				__(
					'Not Supported. (%1$s %2$s See %3$sNewRelic Requirements%4$s page.)',
					'w3-total-cache'
				),
				$os_name,
				$os_version,
				'<a href="https://docs.newrelic.com/docs/apm/agents/php-agent/getting-started/php-agent-compatibility-requirements/" target="_blank">',
				'</a>'
			);

		/**
		 * Apache 2.2 or 2.4 via mod_php
		 * Or any web server that supports FastCGI using php-fpm
		 */
		$server_software = isset( $_SERVER['SERVER_SOFTWARE'] ) ? sanitize_text_field( wp_unslash( $_SERVER['SERVER_SOFTWARE'] ) ) : '';
		$server          = explode( '/', $server_software );
		$ws_check        = false;
		$ws_name         = $server_software;
		$ws_version      = '';

		if ( count( $server ) > 1 ) {
			$ws_name    = $server[0];
			$ws_version = $server[1];
			$version    = explode( '.', $ws_version );
			if ( count( $version ) > 1 ) {
				$ws_version = sprintf( '%d.%d', $version[0], $version[1] );
			}
		}
		switch ( true ) {
			case Util_Environment::is_apache():
				if ( $ws_version ) {
					$ws_check = version_compare( $ws_version, '2.2', '>=' );
				}
				break;
			case Util_Environment::is_nginx():
				$ws_check = 'fpm-fcgi' === php_sapi_name();
				$ws_name .= php_sapi_name();
				break;
			default:
				$ws_check   = 'fpm-fcgi' === php_sapi_name();
				$ws_name    = $server_software;
				$ws_version = '';
		}
		$verified[ __( 'Web Server', 'w3-total-cache' ) ] = $ws_check ?
			$supported_string :
			sprintf(
				// translators: 1 Web Server name, 2 Web Server version, 3 opening HTML a tag to NewRelic requirments for php, 4 closing HTML a tag.
				__(
					'Not Supported. (%1$s %2$s See %3$sNewRelic Requirements%4$s page.)',
					'w3-total-cache'
				),
				$ws_name,
				$ws_version,
				'<a href="https://docs.newrelic.com/docs/apm/agents/php-agent/getting-started/php-agent-compatibility-requirements/" target="_blank">',
				'</a>'
			);
		return $verified;
	}

	/**
	 * Verifies if the New Relic service is running properly.
	 *
	 * @return mixed An array of error messages or true if everything is configured correctly.
	 *
	 * @throws \Exception If an error occurs while verifying the configuration.
	 */
	public function verify_running() {
		$config = Dispatcher::config();

		$error = array();
		if ( ! $this->get_api_key() ) {
			$error['api_key'] = __( 'API Key is not configured.', 'w3-total-cache' );
		}

		if ( 'browser' === $config->get( array( 'newrelic', 'monitoring_type' ) ) ) {
			$name = $this->get_effective_appname();
			if ( empty( $name ) ) {
				$error['application_id'] = __( 'Application ID is not configured. Enter/Select application name.', 'w3-total-cache' );
			}
		} else {
			if ( ! $this->module_is_enabled() ) {
				$error['module_enabled'] = __( 'PHP module is not enabled.', 'w3-total-cache' );
			}

			if ( ! $this->agent_enabled() ) {
				$error['agent_enabled'] = __( 'PHP agent is not enabled.', 'w3-total-cache' );
			}

			$account_id = $this->get_account_id();
			$app_id     = $this->get_effective_application_id();

			if ( ! $account_id && 0 === $app_id ) {
				$error['account_id'] = __( 'Account ID is not configured.', 'w3-total-cache' );
			}

			if ( 0 === $app_id ) {
				$error['application_id'] = __( 'Application ID is not configured. Enter/Select application name.', 'w3-total-cache' );
			}

			try {
				if ( ! $this->get_license_key_from_ini() ) {
					$error['license'] = __( 'License key could not be detected in ini file.', 'w3-total-cache' );
				}

				$licences = explode( ' ', trim( $this->get_license_key_from_ini() ) );
				$licences = array_map( 'trim', $licences );
				if (
					$this->get_license_key_from_ini() &&
					$this->get_license_key_from_account() &&
					! in_array( trim( $this->get_license_key_from_account() ), $licences, true )
				) {
					$error['license'] = sprintf(
						// Translators: 1 license key, 2 license key list.
						__(
							'Configured license key does not match license key(s) in account: <br />%1$s <br />%2$s',
							'w3-total-cache'
						),
						$this->get_license_key_from_ini(),
						implode( '<br />', $licences )
					);
				}

				$this->get_account_id();
			} catch ( \Exception $ex ) {
				$error['api_key'] = __( 'API Key is invalid.', 'w3-total-cache' );
			}
		}

		return $error ? $error : true;
	}

	/**
	 * Checks if the New Relic PHP agent is enabled.
	 *
	 * @return bool True if the agent is enabled, false otherwise.
	 */
	public function agent_enabled() {
		return ini_get( 'newrelic.enabled' );
	}

	/**
	 * Checks if the New Relic module is enabled in PHP.
	 *
	 * @return bool True if the module is enabled, false otherwise.
	 */
	public function module_is_enabled() {
		return function_exists( 'newrelic_set_appname' );
	}

	/**
	 * Retrieves the New Relic license key from the PHP configuration.
	 *
	 * @return string The New Relic license key.
	 */
	public function get_license_key_from_ini() {
		return ini_get( 'newrelic.license' );
	}

	/**
	 * Retrieves the API key used for authentication with the New Relic service.
	 *
	 * @return string The API key.
	 */
	public function get_api_key() {
		return $this->_api_key;
	}

	/**
	 * Retrieves the New Relic API instance.
	 *
	 * phpcs:disable WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
	 *
	 * @return \NewRelicAPI The API instance for interacting with New Relic.
	 */
	private function getAPI() {
		static $api = null;
		if ( ! $api ) {
			require_once W3TC_LIB_NEWRELIC_DIR . '/NewRelicAPI.php';
			$api = new \NewRelicAPI( $this->_api_key );
		}

		return $api;
	}

	/**
	 * Retrieves a list of applications associated with the New Relic account.
	 *
	 * @return array An array of applications.
	 */
	public function get_applications() {
		if ( empty( $this->_api_key ) ) {
			return array();
		}

		// Account ID is not needed for v2 app listing.
		return $this->getAPI()->get_applications( 0 );
	}

	/**
	 * Retrieves a list of browser applications associated with the New Relic account.
	 *
	 * @return array An array of browser applications.
	 */
	public function get_browser_applications() {
		return $this->getAPI()->get_browser_applications();
	}

	/**
	 * Retrieves a specific application by its ID.
	 *
	 * @param int $application_id The application ID.
	 *
	 * @return array The details of the specified application.
	 */
	public function get_application( $application_id ) {
		$applications = $this->get_applications();
		return $applications[ $application_id ];
	}

	/**
	 * Retrieves the summary of a specific application.
	 *
	 * @return array The application summary.
	 */
	public function get_application_summary() {
		return $this->getAPI()->get_application_summary(
			$this->get_account_id(),
			$this->get_effective_application_id()
		);
	}

	/**
	 * Retrieves the account information associated with the New Relic service.
	 *
	 * @return array The account details.
	 */
	public function get_account() {
		static $account = null;
		if ( ! $account ) {
			$account = $this->getAPI()->get_account();
		}
		return $account;
	}

	/**
	 * Retrieves the subscription details of the New Relic account.
	 *
	 * @return mixed The subscription details or null if not available.
	 */
	public function get_subscription() {
		$account = $this->get_account();
		if ( $account && isset( $account['subscription'] ) ) {
			return $account['subscription'];
		}
		return null;
	}

	/**
	 * Determines whether the current subscription allows metric retrieval.
	 *
	 * @return bool True if the subscription is not 'Lite', false otherwise.
	 */
	public function can_get_metrics() {
		$subscription = $this->get_subscription();
		if ( ! is_array( $subscription ) || ! isset( $subscription['product-name'] ) ) {
			return true;
		}

		return 'Lite' !== $subscription['product-name'];
	}

	/**
	 * Retrieves the license key associated with the current account.
	 *
	 * @return string|null The license key, or null if not found.
	 */
	public function get_license_key_from_account() {
		$account = $this->get_account();
		if ( $account ) {
			return $account['license-key'];
		}
		return null;
	}

	/**
	 * Fetches the application settings for the current account and application.
	 *
	 * @return array The application settings.
	 */
	public function get_application_settings() {
		$settings = $this->getAPI()->get_application_settings(
			$this->get_account_id(),
			$this->get_effective_application_id()
		);

		return $settings;
	}

	/**
	 * Updates the application settings for the current account and application.
	 *
	 * @param array $application The application settings to update.
	 *
	 * @return bool True on success, false on failure.
	 */
	public function update_application_settings( $application ) {
		$result = $this->getAPI()->update_application_settings(
			$this->get_account_id(),
			$this->get_effective_application_id(),
			$application
		);
		return $result;
	}

	/**
	 * Retrieves metric names based on an optional regular expression filter and limit.
	 *
	 * @param string $regex Optional regular expression to filter metric names.
	 * @param string $limit Optional limit for the number of metrics to retrieve.
	 *
	 * @return array An associative array of metric names and their corresponding metric objects.
	 */
	public function get_metric_names( $regex = '', $limit = '' ) {
		$metric_names_object = $this->getAPI()->get_metric_names( $this->get_effective_application_id(), $regex, $limit );
		if ( ! $metric_names_object ) {
			return array();
		}

		$metric_names = array();
		foreach ( $metric_names_object as $metric ) {
			$metric_names[ $metric->name ] = $metric;
		}

		return $metric_names;
	}

	/**
	 * Retrieves metric data for the given metrics and field over a specified number of days.
	 *
	 * phpcs:disable WordPress.NamingConventions.ValidVariableName.VariableNotSnakeCase
	 *
	 * @param array|string $metrics The metrics to fetch data for.
	 * @param string       $field   The field of data to retrieve.
	 * @param int          $days    The number of days of data to retrieve.
	 * @param bool         $summary Whether to summarize the data.
	 * @param bool         $use_subgroup Whether to group data by subgroups.
	 *
	 * @return array An array of formatted metric data.
	 */
	public function get_metric_data( $metrics, $field, $days = 7, $summary = true, $use_subgroup = true ) {
		if ( ! is_array( $metrics ) ) {
			$metrics = array( $metrics );
		}

		$begin     = new \DateTime( gmdate( 'Y-m-d G:i:s', strtotime( ( $days > 1 ? "-$days days" : "-$days day" ) ) ) );
		$beginStr  = $begin->format( 'Y-m-d' ) . 'T' . $begin->format( 'H:i:s' ) . 'Z';
		$to        = new \DateTime( gmdate( 'Y-m-d G:i:s' ) );
		$toStr     = $to->format( 'Y-m-d' ) . 'T' . $to->format( 'H:i:s' ) . 'Z';
		$cache_key = md5(
			implode(
				',',
				array(
					$this->get_account_id(),
					$this->get_effective_application_id(),
					$beginStr,
					$toStr,
					implode( ',', $metrics ),
					$field,
					$summary,
				)
			)
		);

		$metric_data    = $this->getAPI()->get_metric_data(
			$this->get_account_id(),
			$this->get_effective_application_id(),
			$beginStr,
			$toStr,
			$metrics,
			$field,
			$summary
		);
		$formatted_data = array();

		if ( $metric_data ) {
			foreach ( $metric_data as $metric ) {
				$path  = explode( '/', $metric->name );
				$group = $path[0];
				if ( $use_subgroup ) {
					$subgroup                                = isset( $path[1] ) ? ( 'all' === $path[1] ? 0 : $path[1] ) : 0;
					$formatted_data[ $group ][ $subgroup ][] = $metric;
				} else {
					$formatted_data[ $group ][] = $metric;
				}
			}
		}

		return $formatted_data;
	}

	/**
	 * Retrieves a set of dashboard metrics for monitoring.
	 *
	 * @return array An array of formatted dashboard metric data.
	 */
	public function get_dashboard_metrics() {
		$metrics = array( 'Datastore/all', 'WebTransaction', 'EndUser' );
		$field   = 'average_response_time';
		return $this->get_metric_data( $metrics, $field, 1, true );
	}

	/**
	 * Retrieves the slowest page load times for web transactions.
	 *
	 * @return array An associative array of slowest page loads by transaction name and response time.
	 */
	public function get_slowest_page_load() {
		$metric_names = $this->get_metric_names( 'EndUser/WebTransaction/WebTransaction/' );

		$metric_names_keys = array_keys( $metric_names );
		$metric_data       = $this->get_metric_data( $metric_names_keys, 'average_response_time', 1 );
		$slowest           = array();

		if ( $metric_data ) {
			$transactions = $metric_data['EndUser']['WebTransaction'];
			foreach ( $transactions as $transaction ) {
				$key             = str_replace( 'EndUser/WebTransaction/WebTransaction', '', $transaction->name );
				$slowest[ $key ] = $transaction->average_response_time;
			}
			$slowest = $this->_sort_and_slice( $slowest, 5 );
		}
		return $slowest;
	}

	/**
	 * Retrieves the slowest web transactions based on response time.
	 *
	 * @return array An associative array of the slowest web transactions by name and response time.
	 */
	public function get_slowest_webtransactions() {
		$metric_names      = $this->get_metric_names( '^WebTransaction/' );
		$metric_names_keys = array_keys( $metric_names );
		$metric_data       = $this->get_metric_data( $metric_names_keys, 'average_response_time', 1 );
		$slowest           = array();
		if ( $metric_data ) {
			$transactions = $metric_data['WebTransaction'];
			foreach ( $transactions as $transaction ) {
				foreach ( $transaction as $tr_sub ) {
					$key             = str_replace( 'WebTransaction', '', $tr_sub->name );
					$slowest[ $key ] = $tr_sub->average_response_time;
				}
			}
			$slowest = $this->_sort_and_slice( $slowest, 5 );
		}
		return $slowest;
	}

	/**
	 * Retrieves the slowest database transactions based on response time.
	 *
	 * @return array An associative array of the slowest database transactions by name and response time.
	 */
	public function get_slowest_database() {
		// Prefer Datastore metrics (v2); fall back to Database if empty.
		$metric_names      = $this->get_metric_names( '^Datastore/' );
		$metric_group_key  = 'Datastore';
		if ( empty( $metric_names ) ) {
			$metric_names     = $this->get_metric_names( '^Database/' );
			$metric_group_key = 'Database';
		}

		$metric_names_keys = array_keys( $metric_names );
		if ( empty( $metric_names_keys ) ) {
			return array();
		}

		// Limit to top 25 metric names to avoid huge query strings.
		$metric_names_keys = array_slice( $metric_names_keys, 0, 25 );

		$metric_data = $this->get_metric_data( $metric_names_keys, 'average_response_time', 1, true, false );
		if ( empty( $metric_data ) || empty( $metric_data[ $metric_group_key ] ) ) {
			// Try fallback field if response time is absent.
			$metric_data = $this->get_metric_data( $metric_names_keys, 'average_value', 1, true, false );
			if ( empty( $metric_data ) || empty( $metric_data[ $metric_group_key ] ) ) {
				return array();
			}
		}

		$slowest     = array();
		$transactions = $metric_data[ $metric_group_key ];
		foreach ( $transactions as $transaction ) {
			$key   = str_replace( $metric_group_key, '', $transaction->name );
			$value = isset( $transaction->average_response_time ) ? $transaction->average_response_time : ( $transaction->average_value ?? null );
			if ( null === $value ) {
				continue;
			}
			$slowest[ $key ] = $value;
		}

		return $this->_sort_and_slice( $slowest, 5 );
	}

	/**
	 * Retrieves the frontend response time metric.
	 *
	 * @return float The average frontend response time.
	 */
	public function get_frontend_response_time() {
		$metric_data = $this->get_metric_data( 'EndUser', 'average_fe_response_time', 1, true, false );
		return isset( $metric_data['EndUser'] ) ? $metric_data['EndUser'][0]->average_fe_response_time : 0;
	}

	/**
	 * Sorts and slices the given slowest data to a specified size.
	 *
	 * @param array $slowest The array of slowest data to sort.
	 * @param int   $size    The number of top slowest items to return.
	 *
	 * @return array The top slowest data, sorted and sliced.
	 */
	private function _sort_and_slice( $slowest, $size ) {
		arsort( $slowest, SORT_NUMERIC );
		if ( count( $slowest ) > $size ) {
			$slowest = array_slice( $slowest, 0, $size );
		}
		return $slowest;
	}

	/**
	 * Retrieves the name of an application based on its ID.
	 *
	 * @param int $application_id The ID of the application.
	 *
	 * @return string The application name, or an empty string if not found.
	 */
	public function get_application_name( $application_id ) {
		$apps = $this->get_applications();
		return isset( $apps[ $application_id ] ) ? $apps[ $application_id ] : '';
	}

	/**
	 * Retrieves the account ID associated with the current API key.
	 *
	 * @return int The account ID, or 0 if not found or invalid.
	 */
	public function get_account_id() {
		if ( empty( $this->_api_key ) ) {
			return 0;
		}

		$ids_string = get_option( 'w3tc_nr_account_id' );
		$ids        = @json_decode( $ids_string, true );
		if ( ! is_array( $ids ) ) {
			$ids = array();
		}

		if ( isset( $ids[ $this->_api_key ] ) && $ids[ $this->_api_key ] > 0 ) {
			return $ids[ $this->_api_key ];
		}

		$account_id = 0;

		try {
			$account = $this->getAPI()->get_account();
			if ( $account && ! empty( $account['id'] ) ) {
				$account_id = (int) $account['id'];
			}
		} catch ( \Exception $ex ) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch
		}

		// Fallback: derive from the selected application details (safe, no recursion).
		if ( 0 === $account_id ) {
			$app_id = $this->get_effective_application_id();
			if ( $app_id ) {
				try {
					$app_details = $this->getAPI()->get_application( $app_id );
					if ( isset( $app_details['account_id'] ) ) {
						$account_id = (int) $app_details['account_id'];
					}
				} catch ( \Exception $app_ex ) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch
				}
			}
		}

		if ( $account_id > 0 ) {
			$ids[ $this->_api_key ] = $account_id;
			update_option( 'w3tc_nr_account_id', wp_json_encode( $ids ) );

			// Persist to config for visibility/use elsewhere.
			$config = Dispatcher::config();
			if ( $config->get_integer( array( 'newrelic', 'account_id' ) ) !== $account_id ) {
				$config->set( array( 'newrelic', 'account_id' ), $account_id );
				$config->save();
			}

			return $account_id;
		}

		return 0;
	}

	/**
	 * Retrieves the application ID based on the application name.
	 *
	 * @param string $appname The application name.
	 *
	 * @return int The application ID, or 0 if not found.
	 */
	public function get_application_id( $appname ) {
		if ( empty( $appname ) ) {
			return 0;
		}

		$apps = $this->get_applications();
		foreach ( $apps as $id => $name ) {
			if ( $name === $appname ) {
				return $id;
			}
		}
		return 0;
	}

	/**
	 * Retrieves the effective application ID based on the current configuration and API key.
	 *
	 * @return int The effective application ID, or 0 if an error occurs.
	 */
	public function get_effective_application_id() {
		$config = Dispatcher::config();

		$monitoring_type = $config->get_string( array( 'newrelic', 'monitoring_type' ) );
		if ( 'browser' === $monitoring_type ) {
			return $config->get_string( array( 'newrelic', 'browser.application_id' ) );
		}

		$appname    = $this->get_effective_appname();
		$ids_string = get_option( 'w3tc_nr_application_id' );
		$ids        = @json_decode( $ids_string, true );
		if ( ! is_array( $ids ) ) {
			$ids = array();
		}

		$key = md5( $this->_api_key . $appname );
		if ( isset( $ids[ $key ] ) ) {
			return $ids[ $key ];
		}

		try {
			$ids[ $key ] = $this->get_application_id( $appname );
		} catch ( \Exception $ex ) {
			return 0;
		}

		update_option( 'w3tc_nr_application_id', wp_json_encode( $ids ) );

		return $ids[ $key ];
	}

	/**
	 * Retrieves the effective application name based on the current configuration and monitoring type.
	 *
	 * @return string The effective application name.
	 */
	public function get_effective_appname() {
		$config = Dispatcher::config();

		$monitoring_type = $config->get_string( array( 'newrelic', 'monitoring_type' ) );
		if ( 'browser' === $monitoring_type ) {
			$core = Dispatcher::component( 'Extension_NewRelic_Core' );
			$a    = $core->get_effective_browser_application();
			if ( isset( $a['name'] ) ) {
				return $a['name'];
			}

			return '?';
		}

		return $config->get_string( array( 'newrelic', 'apm.application_name' ) );
	}
}
