class SensorResult in Monitoring 8

Same name and namespace in other branches

7 lib/Drupal/monitoring/Result/SensorResult.php \Drupal\monitoring\Result\SensorResult

Generic container for the sensor result.

@todo more

Hierarchy

class \Drupal\monitoring\Result\SensorResult implements SensorResultInterface

Expanded class hierarchy of SensorResult

File

src/Result/SensorResult.php, line 19

Namespace

Drupal\monitoring\Result

View source

class SensorResult implements SensorResultInterface {

  /**
   * The sensor config instance.
   *
   * @var \Drupal\monitoring\Entity\SensorConfig
   */
  protected $sensorConfig;

  /**
   * If the current result was constructed from a cache.
   *
   * @var bool
   */
  protected $isCached = FALSE;

  /**
   * The sensor result data.
   *
   * @var array
   */
  protected $data = array();

  /**
   * Additional status messages from addStatusMessage().
   *
   * @var string[]
   */
  protected $statusMessages = array();

  /**
   * The main sensor message from setMessage().
   *
   * @var string[]
   */
  protected $sensorMessage = array();

  /**
   * The verbose output of the sensor execution.
   *
   * @var string
   */
  protected $verboseOutput;

  /**
   * The previous sensor result.
   *
   * @var \Drupal\monitoring\Entity\SensorResultDataInterface|null
   */
  protected $previousResult = NULL;

  /**
   * Instantiates a sensor result object.
   *
   * By default, the sensor status is STATUS_UNKNOWN with empty message.
   *
   * @param \Drupal\monitoring\Entity\SensorConfig $sensor_config
   *   Sensor config object.
   * @param array $cached_data
   *   Result data obtained from a cache.
   */
  function __construct(SensorConfig $sensor_config, array $cached_data = array()) {
    $this->sensorConfig = $sensor_config;
    if ($cached_data) {
      $this->data = $cached_data;
      $this->isCached = TRUE;
    }

    // Merge in defaults in case there is nothing cached for given sensor yet.
    $this->data += array(
      'sensor_status' => SensorResultInterface::STATUS_UNKNOWN,
      'sensor_message' => NULL,
      'sensor_expected_value' => NULL,
      'sensor_value' => NULL,
      'execution_time' => 0,
      'timestamp' => \Drupal::time()
        ->getRequestTime(),
    );
  }

  /**
   * Sets result data.
   *
   * @param string $key
   *   Data key.
   * @param mixed $value
   *   Data to set.
   */
  protected function setResultData($key, $value) {
    $this->data[$key] = $value;
    $this->isCached = FALSE;
  }

  /**
   * Gets result data.
   *
   * @param string $key
   *   Data key.
   *
   * @return mixed
   *   Stored data.
   */
  protected function getResultData($key) {
    return $this->data[$key];
  }

  /**
   * {@inheritdoc}
   */
  public function getStatus() {
    return $this
      ->getResultData('sensor_status');
  }

  /**
   * {@inheritdoc}
   */
  public static function getStatusLabels() {
    return [
      self::STATUS_CRITICAL => t('Critical'),
      self::STATUS_WARNING => t('Warning'),
      self::STATUS_INFO => t('Info'),
      self::STATUS_OK => t('OK'),
      self::STATUS_UNKNOWN => t('Unknown'),
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function getStatusLabel() {
    $labels = self::getStatusLabels();
    return $labels[$this
      ->getResultData('sensor_status')];
  }

  /**
   * {@inheritdoc}
   */
  public function getMessage() {
    return $this
      ->getResultData('sensor_message');
  }

  /**
   * {@inheritdoc}
   */
  public function setMessage($message, array $variables = array()) {
    $this->sensorMessage = array(
      'message' => $message,
      'variables' => $variables,
    );
  }

  /**
   * {@inheritdoc}
   */
  public function addStatusMessage($message, array $variables = array()) {
    $this->statusMessages[] = array(
      'message' => $message,
      'variables' => $variables,
    );
  }

  /**
   * {@inheritdoc}
   */
  public function compile() {

    // If the status is unknown we do the value assessment through
    // configurable thresholds.
    $threshold_message = NULL;
    if ($this
      ->isUnknown()) {
      if ($this
        ->getSensorConfig()
        ->isDefiningThresholds()) {
        $threshold_message = $this
          ->assessThresholds();
      }
      elseif ($this
        ->getExpectedValue() !== NULL) {
        $this
          ->assessComparison();
      }
      elseif ($this
        ->getSensorConfig()
        ->isNumeric()) {

        // Numeric sensors that do not have thresholds or an expected value
        // default to OK.
        $this
          ->setStatus(SensorResultInterface::STATUS_OK);
      }
    }
    if ($this
      ->getSensorConfig()
      ->getValueType() == 'bool') {
      $msg_expected = $this
        ->getExpectedValue() ? 'TRUE' : 'FALSE';
    }
    else {
      $msg_expected = $this
        ->getExpectedValue();
    }
    if (!empty($this->sensorMessage)) {

      // A message has been set by the sensor, use that as is and only do
      // placeholder replacements with the provided variables.
      $message = new FormattableMarkup($this->sensorMessage['message'], $this->sensorMessage['variables']);
    }
    else {

      // No message has been provided, attempt to build one.
      // Set the default message variables.
      $default_variables = array(
        '@sensor' => $this
          ->getSensorId(),
        '@formatted_value' => $this
          ->getFormattedValue($this
          ->getValue()),
        '@time' => $this
          ->getTimestamp(),
        '@expected' => $msg_expected,
        '@time_interval' => \Drupal::service('date.formatter')
          ->formatInterval($this
          ->getSensorConfig()
          ->getTimeIntervalValue()),
      );

      // Build an array of message parts.
      $messages = array();

      // Add the sensor value if provided.
      if ($this
        ->getValue() !== NULL) {

        // If the sensor defines time interval value we append
        // the info to the message.
        if ($this
          ->getSensorConfig()
          ->getTimeIntervalValue()) {
          $messages[] = new FormattableMarkup('@formatted_value in @time_interval', $default_variables);
        }
        else {
          $messages[] = $default_variables['@formatted_value'];
        }
      }
      elseif (empty($this->statusMessages)) {
        $messages[] = 'No value';
      }

      // Set the expected value message if the sensor did not match.
      if ($this
        ->isCritical() && $this
        ->getExpectedValue() !== NULL) {
        $messages[] = new FormattableMarkup('expected @expected', $default_variables);
      }

      // Set the threshold message if there is any.
      if ($threshold_message !== NULL) {
        $messages[] = $threshold_message;
      }
      $renderer = \Drupal::service('renderer');

      // Append all status messages which were added by the sensor.
      foreach ($this->statusMessages as $msg) {
        if (is_array($msg['message'])) {
          $messages[] = new FormattableMarkup($renderer
            ->renderPlain($msg['message']), array_merge($default_variables, $msg['variables']));
        }
        else {
          $messages[] = new FormattableMarkup($msg['message'], array_merge($default_variables, $msg['variables']));
        }
      }
      $message = strip_tags(implode(', ', $messages));
    }
    $this
      ->setResultData('sensor_message', $message);
  }

  /**
   * Performs comparison of expected and actual sensor values.
   */
  protected function assessComparison() {
    if ($this
      ->getValue() != $this
      ->getExpectedValue()) {
      $this
        ->setStatus(SensorResultInterface::STATUS_CRITICAL);
    }
    else {
      $this
        ->setStatus(SensorResultInterface::STATUS_OK);
    }
  }

  /**
   * Deal with thresholds.
   *
   * Set the sensor value  based on threshold configuration.
   *
   * @return string
   *   The message associated with the threshold.
   *
   * @see \Drupal\monitoring\Sensor\Thresholds
   */
  protected function assessThresholds() {
    $thresholds = new Thresholds($this->sensorConfig);
    $matched_threshold = $thresholds
      ->getMatchedThreshold($this
      ->getValue());

    // Set sensor status based on matched threshold.
    $this
      ->setStatus($matched_threshold);

    // @todo why not just set the status message?
    return $thresholds
      ->getStatusMessage();
  }

  /**
   * Formats the value to be human readable.
   *
   * @param mixed $value
   *   Sensor result value.
   *
   * @return string
   *   Formatted value.
   *
   * @throws \Drupal\monitoring\Sensor\SensorCompilationException
   */
  public function getFormattedValue($value) {
    $value_type = $this
      ->getSensorConfig()
      ->getValueType();

    // If the value type is defined we have the formatter that will format the
    // value to be ready for display.
    if (!empty($value_type)) {
      $value_types = monitoring_value_types();
      if (!isset($value_types[$value_type])) {
        throw new SensorCompilationException(new FormattableMarkup('Invalid value type @type', array(
          '@type' => $value_type,
        )));
      }
      elseif (empty($value_types[$value_type]['formatter_callback']) && ($label = $this
        ->getSensorConfig()
        ->getValueLabel())) {
        $label = mb_strtolower($label);
        return new FormattableMarkup('@value @label', array(
          '@value' => $value,
          '@label' => $label,
        ));
      }
      elseif (isset($value_types[$value_type]['formatter_callback']) && !function_exists($value_types[$value_type]['formatter_callback'])) {
        throw new SensorCompilationException(new FormattableMarkup('Formatter callback @callback for @type does not exist', array(
          '@callback' => $value_types[$value_type]['formatter_callback'],
          '@type' => $value_type,
        )));
      }
      elseif (isset($value_types[$value_type]['formatter_callback'])) {
        $callback = $value_types[$value_type]['formatter_callback'];
        return $callback($this);
      }
    }

    // If there is no value formatter we try to provide something human readable
    // by concatenating the value and label.
    if ($label = $this
      ->getSensorConfig()
      ->getValueLabel()) {

      // @todo This assumption will no longer work when non-english messages
      // supported.
      $label = mb_strtolower($label);
      return new FormattableMarkup('@value @label', array(
        '@value' => $value,
        '@label' => $label,
      ));
    }
    return new FormattableMarkup('Value @value', array(
      '@value' => $value,
    ));
  }

  /**
   * {@inheritdoc}
   */
  public function getValue() {
    if ($this
      ->getSensorConfig()
      ->isBool()) {
      return (bool) $this
        ->getResultData('sensor_value');
    }
    return $this
      ->getResultData('sensor_value');
  }

  /**
   * {@inheritdoc}
   */
  public function getExpectedValue() {
    if ($this
      ->getSensorConfig()
      ->isBool()) {
      return (bool) $this
        ->getResultData('sensor_expected_value');
    }
    return $this
      ->getResultData('sensor_expected_value');
  }

  /**
   * {@inheritdoc}
   */
  public function getExecutionTime() {
    return round($this
      ->getResultData('execution_time'), 2);
  }

  /**
   * {@inheritdoc}
   */
  public function setStatus($sensor_status) {
    $this
      ->setResultData('sensor_status', $sensor_status);
  }

  /**
   * {@inheritdoc}
   */
  public function setValue($sensor_value) {
    $this
      ->setResultData('sensor_value', $sensor_value);
  }

  /**
   * {@inheritdoc}
   */
  public function setExpectedValue($sensor_value) {
    $this
      ->setResultData('sensor_expected_value', $sensor_value);
  }

  /**
   * {@inheritdoc}
   */
  public function setExecutionTime($execution_time) {
    $this
      ->setResultData('execution_time', $execution_time);
  }

  /**
   * {@inheritdoc}
   */
  public function toNumber() {
    $sensor_value = $this
      ->getValue();
    if (is_numeric($sensor_value)) {
      return $sensor_value;
    }

    // Casting to int should be good enough as boolean will get casted to 0/1
    // and string as well.
    return (int) $sensor_value;
  }

  /**
   * {@inheritdoc}
   */
  public function isWarning() {
    return $this
      ->getStatus() == SensorResultInterface::STATUS_WARNING;
  }

  /**
   * {@inheritdoc}
   */
  public function isCritical() {
    return $this
      ->getStatus() == SensorResultInterface::STATUS_CRITICAL;
  }

  /**
   * {@inheritdoc}
   */
  public function isUnknown() {
    return $this
      ->getStatus() == SensorResultInterface::STATUS_UNKNOWN;
  }

  /**
   * {@inheritdoc}
   */
  public function isOk() {
    return $this
      ->getStatus() == SensorResultInterface::STATUS_OK;
  }

  /**
   * Returns sensor result data as array.
   *
   * @return array
   *   An array with data having following keys:
   *   - sensor_name
   *   - value
   *   - expected_value
   *   - numeric_value
   *   - status
   *   - message
   *   - execution_time
   *   - timestamp
   */
  public function toArray() {
    return array(
      'sensor_name' => $this
        ->getSensorId(),
      'value' => $this
        ->getValue(),
      'expected_value' => $this
        ->getExpectedValue(),
      'numeric_value' => $this
        ->toNumber(),
      'status' => $this
        ->getStatus(),
      'message' => $this
        ->getMessage(),
      'execution_time' => $this
        ->getExecutionTime(),
      'timestamp' => $this
        ->getTimestamp(),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function isCached() {
    return $this->isCached;
  }

  /**
   * {@inheritdoc}
   */
  public function getTimestamp() {
    return $this
      ->getResultData('timestamp');
  }

  /**
   * {@inheritdoc}
   */
  public function getSensorId() {
    return $this->sensorConfig
      ->id();
  }

  /**
   * {@inheritdoc}
   */
  public function getSensorConfig() {
    return $this->sensorConfig;
  }

  /**
   * {@inheritdoc}
   */
  public function setVerboseOutput($verbose_output) {
    $this->verboseOutput = $verbose_output;
  }

  /**
   * {@inheritdoc}
   */
  public function getVerboseOutput() {
    return $this->verboseOutput;
  }

  /**
   * {@inheritdoc}
   */
  public function setPreviousResult(SensorResultDataInterface $previous_result = NULL) {
    $this->previousResult = $previous_result;
  }

  /**
   * {@inheritdoc}
   */
  public function getPreviousResult() {
    return $this->previousResult;
  }

}

Members

Name	Modifiers	Type	Description
SensorResult::$data	protected	property	The sensor result data.
SensorResult::$isCached	protected	property	If the current result was constructed from a cache.
SensorResult::$previousResult	protected	property	The previous sensor result.
SensorResult::$sensorConfig	protected	property	The sensor config instance.
SensorResult::$sensorMessage	protected	property	The main sensor message from setMessage().
SensorResult::$statusMessages	protected	property	Additional status messages from addStatusMessage().
SensorResult::$verboseOutput	protected	property	The verbose output of the sensor execution.
SensorResult::addStatusMessage	public	function	Adds sensor status message. Overrides SensorResultInterface::addStatusMessage
SensorResult::assessComparison	protected	function	Performs comparison of expected and actual sensor values.
SensorResult::assessThresholds	protected	function	Deal with thresholds.
SensorResult::compile	public	function	Compiles added status messages sets the status. Overrides SensorResultInterface::compile
SensorResult::getExecutionTime	public	function	Get sensor execution time in ms. Overrides SensorResultDataInterface::getExecutionTime
SensorResult::getExpectedValue	public	function	Gets the sensor expected value. Overrides SensorResultInterface::getExpectedValue
SensorResult::getFormattedValue	public	function	Formats the value to be human readable. Overrides SensorResultInterface::getFormattedValue
SensorResult::getMessage	public	function	Gets sensor status message. Overrides SensorResultDataInterface::getMessage
SensorResult::getPreviousResult	public	function	Gets the previous sensor result. Overrides SensorResultInterface::getPreviousResult
SensorResult::getResultData	protected	function	Gets result data.
SensorResult::getSensorConfig	public	function	Gets sensor config. Overrides SensorResultInterface::getSensorConfig
SensorResult::getSensorId	public	function	Gets sensor name. Overrides SensorResultInterface::getSensorId
SensorResult::getStatus	public	function	Gets sensor status. Overrides SensorResultDataInterface::getStatus
SensorResult::getStatusLabel	public	function	Gets a human readable label for the sensor status. Overrides SensorResultDataInterface::getStatusLabel
SensorResult::getStatusLabels	public static	function
SensorResult::getTimestamp	public	function	The result data timestamp. Overrides SensorResultDataInterface::getTimestamp
SensorResult::getValue	public	function	Gets the sensor metric value. Overrides SensorResultDataInterface::getValue
SensorResult::getVerboseOutput	public	function	Returns the verbose output. Overrides SensorResultInterface::getVerboseOutput
SensorResult::isCached	public	function	Determines if data for given result object are cached. Overrides SensorResultInterface::isCached
SensorResult::isCritical	public	function	Checks if sensor is in CRITICAL state. Overrides SensorResultInterface::isCritical
SensorResult::isOk	public	function	Checks if sensor is in OK state. Overrides SensorResultInterface::isOk
SensorResult::isUnknown	public	function	Checks if sensor is in UNKNOWN state. Overrides SensorResultInterface::isUnknown
SensorResult::isWarning	public	function	Checks if sensor is in WARNING state. Overrides SensorResultInterface::isWarning
SensorResult::setExecutionTime	public	function	Sets sensor execution time in ms. Overrides SensorResultInterface::setExecutionTime
SensorResult::setExpectedValue	public	function	Sets sensor expected value. Overrides SensorResultInterface::setExpectedValue
SensorResult::setMessage	public	function	Sets the final result message. Overrides SensorResultInterface::setMessage
SensorResult::setPreviousResult	public	function	Sets the previous sensor result. Overrides SensorResultInterface::setPreviousResult
SensorResult::setResultData	protected	function	Sets result data.
SensorResult::setStatus	public	function	Sets sensor status. Overrides SensorResultInterface::setStatus
SensorResult::setValue	public	function	Sets sensor value. Overrides SensorResultInterface::setValue
SensorResult::setVerboseOutput	public	function	Set the verbose output. Overrides SensorResultInterface::setVerboseOutput
SensorResult::toArray	public	function	Returns sensor result data as array. Overrides SensorResultInterface::toArray
SensorResult::toNumber	public	function	Casts/processes the sensor value into numeric representation. Overrides SensorResultInterface::toNumber
SensorResult::__construct		function	Instantiates a sensor result object.
SensorResultDataInterface::STATUS_CRITICAL		constant	Sensor status CRITICAL.
SensorResultDataInterface::STATUS_INFO		constant	Sensor status INFO.
SensorResultDataInterface::STATUS_OK		constant	Sensor status OK.
SensorResultDataInterface::STATUS_UNKNOWN		constant	Sensor status UNKNOWN.
SensorResultDataInterface::STATUS_WARNING		constant	Sensor status WARNING.

You are here

class SensorResult in Monitoring 8

Hierarchy

See also

File

Namespace

Members

API Navigation