Merge branch 'bugfix/failsafe-perfdata-parser-5973'

fixes #5973

library/Icinga/Application/Cli.php

@@ -79,7 +79,7 @@ class Cli extends ApplicationBootstrap
                 array(
                     'enable' => true,
                     'level'  => Logger::$INFO,
-                    'type'   => 'stream',
+                    'type'   => 'file',
                     'target' => 'php://stderr'
                 )
             )

library/Icinga/Util/Format.php

@@ -50,6 +50,9 @@ class Format
     );
     protected static $byteBase = array(1024, 1000);
 
+    protected static $secondPrefix = array('s', 'ms', 'µs', 'ns', 'ps', 'fs', 'as');
+    protected static $secondBase = 1000;
+
     public static function getInstance()
     {
         if (self::$instance === null) {
@@ -76,6 +79,20 @@ class Format
         );
     }
 
+    public static function seconds($value)
+    {
+        if ($value < 60) {
+            return self::formatForUnits($value, self::$secondPrefix, self::$secondBase);
+        } elseif ($value < 3600) {
+            return sprintf('0.2f m', $value / 60);
+        } elseif ($value < 86400) {
+            return sprintf('0.2f h', $value / 3600);
+        }
+
+        // TODO: Do we need weeks, months and years?
+        return sprintf('0.2f d', $value / 86400);
+    }
+
     public static function duration($duration)
     {
         if ($duration === null || $duration === false) {
@@ -148,7 +165,7 @@ class Format
             '%s%0.2f %s',
             $sign,
             $result,
-            $units[$pow]
+            $units[abs($pow)]
         );
     }
 

modules/monitoring/application/clicommands/ListCommand.php

@@ -263,9 +263,9 @@ class ListCommand extends Command
             try {
                 $pset = PerfdataSet::fromString($row->service_perfdata);
                 $perfs = array();
-                foreach ($pset->getAll() as $perfName => $p) {
+                foreach ($pset as $perfName => $p) {
                     if ($percent = $p->getPercentage()) {
-                        if ($percent < 0 || $percent > 300) {
+                        if ($percent < 0 || $percent > 100) {
                             continue;
                         }
                         $perfs[] = ' '

modules/monitoring/application/views/helpers/Perfdata.php

@@ -1,90 +1,82 @@
 <?php
+// {{{ICINGA_LICENSE_HEADER}}}
+// {{{ICINGA_LICENSE_HEADER}}}
 
-use Icinga\Module\Monitoring\Plugin\PerfdataSet;
+use Icinga\Util\Format;
 use Icinga\Web\Widget\Chart\InlinePie;
+use Icinga\Module\Monitoring\Plugin\Perfdata;
+use Icinga\Module\Monitoring\Plugin\PerfdataSet;
 
 class Zend_View_Helper_Perfdata extends Zend_View_Helper_Abstract
 {
-    public function perfdata($perfdata, $compact = false, $float = 'right')
+    public function perfdata($perfdataStr, $compact = false)
     {
-
-        if (empty($perfdata)) {
-            return '';
-        }
-        if ($float) {
-            $float = ' float: ' . $float . ';';
-        } else {
-            $float = '';
-        }
-
-        $pset = PerfdataSet::fromString($perfdata);
-        $ps = $pset->getAll();
-        $perfdata = preg_replace_callback('~\'([^\']+)\'~', function($match) { return str_replace(' ', '\'', $match[1]); }, $perfdata);
-        $parts = preg_split('~\s+~', $perfdata, -1, PREG_SPLIT_NO_EMPTY);
-
-        $table = array();
         $result = '';
-        if ($compact === true) {
+        $table = array();
-            $compact = 5;
+        $pset = array_slice(PerfdataSet::fromString($perfdataStr)->asArray(), 0, ($compact ? 5 : null));
-        }
+        foreach ($pset as $label => $perfdata) {
-        if ($compact && count($parts) > $compact) {
+            if (!$perfdata->isPercentage() && $perfdata->getMaximumValue() === null) {
-            $parts = array_slice($parts, 0, $compact);
-        }
-        foreach ($parts as $part) {
-            if (strpos($part, '=') === false) continue;
-            list($name, $vals) = preg_split('~=~', $part, 2);
-            $name = str_replace("'", ' ', $name);
-            $parts = preg_split('~;~', $vals, 5);
-            while (count($parts) < 5) $parts[] = null;
-            list($val, $warn, $crit, $min, $max) = $parts;
-
-            $unit = '';
-            if (preg_match('~^([\d+\.]+)([^\d]+)$~', $val, $m)) {
-                $unit = $m[2];
-                $val = $m[1];
-            } else {
                 continue;
             }
-            if ($unit == 'c') continue; // Counter pie graphs are not useful
+
-            if ($compact && $val < 0.0001) continue;
+            $pieChart = new InlinePie($this->calculatePieChartData($perfdata));
-            if ($unit == '%') {
-                if (! $min ) $min = 0;
-                if (! $max) $max = 100;
-            } else {
-                if (! $max && $crit > 0) $max = $crit;
-                //return '';
-            }
-            if (! $max) continue;
-            $green = 0;
-            $orange = 0;
-            $red = 0;
-            $gray = $max - $val;
-            if ($val < $warn) $green = $val;
-            elseif ($val < $crit) $orange = $val;
-            else $red = $val;
-            $inlinePie = new InlinePie(array($green, $orange, $red, $gray));
             if ($compact) {
-                $inlinePie->setTitle(htmlspecialchars($name) . ': ' . htmlspecialchars($ps[$name]->getFormattedValue()));
+                $pieChart->setTitle(
-                $inlinePie->setStyle('float: right;');
+                    htmlspecialchars($label) . ': ' . htmlspecialchars($this->formatPerfdataValue($perfdata))
-                $result .= $inlinePie->render();
+                );
+                $pieChart->setStyle('float: right;');
+                $result .= $pieChart->render();
             } else {
-                $inlinePie->setTitle(htmlspecialchars($name));
+                $pieChart->setTitle(htmlspecialchars($label));
-                $inlinePie->setStyle('float: left; margin: 0.2em 0.5em 0.2em 0;');
+                $pieChart->setStyle('float: left; margin: 0.2em 0.5em 0.2em 0;');
-                $table[] = '<tr><th>' . $inlinePie->render()
+                $table[] = '<tr><th>' . $pieChart->render()
-                    . htmlspecialchars($name)
+                    . htmlspecialchars($label)
                     . '</th><td>'
-                    . htmlspecialchars($ps[$name]->getFormattedValue()) .
+                    . htmlspecialchars($this->formatPerfdataValue($perfdata)) .
                     '</td></tr>';
             }
         }
-        if ($result == '' && ! $compact) {
+
-            $result = $perfdata;
+        // TODO: What if we have both? And should we trust sprintf-style placeholders in perfdata titles?
+        if (empty($table)) {
+            return $compact ? $result : $perfdataStr;
+        } else {
+            return '<table class="perfdata">' . implode("\n", $table) . '</table>';
         }
-        if (! empty($table)) {
+    }
-            // TODO: What if we have both? And should we trust sprintf-style placeholders in perfdata titles?
+
-            $result = '<table class="perfdata">' . implode("\n", $table) . '</table>';
+    protected function calculatePieChartData(Perfdata $perfdata)
+    {
+        $rawValue = $perfdata->getValue();
+        $minValue = $perfdata->getMinimumValue() !== null ? $perfdata->getMinimumValue() : 0;
+        $maxValue = $perfdata->getMaximumValue();
+        $usedValue = ($rawValue - $minValue);
+        $unusedValue = ($maxValue - $minValue) - $usedValue;
+
+        $gray = $unusedValue;
+        $green = $orange = $red = 0;
+        // TODO(#6122): Add proper treshold parsing.
+        if ($perfdata->getCriticalTreshold() && $perfdata->getValue() > $perfdata->getCriticalTreshold()) {
+            $red = $usedValue;
+        } elseif ($perfdata->getWarningTreshold() && $perfdata->getValue() > $perfdata->getWarningTreshold()) {
+            $orange = $usedValue;
+        } else {
+            $green = $usedValue;
         }
 
-        return $result;
+        return array($green, $orange, $red, $gray);
+    }
+
+    protected function formatPerfdataValue(Perfdata $perfdata)
+    {
+        if ($perfdata->isBytes()) {
+            return Format::bytes($perfdata->getValue());
+        } elseif ($perfdata->isSeconds()) {
+            return Format::seconds($perfdata->getValue());
+        } elseif ($perfdata->isPercentage()) {
+            return $perfdata->getValue() . '%';
+        }
+
+        return $perfdata->getValue();
     }
 }

modules/monitoring/library/Monitoring/Plugin/Perfdata.php

@@ -1,223 +1,280 @@
 <?php
+// {{{ICINGA_LICENSE_HEADER}}}
+// {{{ICINGA_LICENSE_HEADER}}}
 
 namespace Icinga\Module\Monitoring\Plugin;
 
+use Icinga\Exception\ProgrammingError;
+
 class Perfdata
 {
-    const COUNTER = 0x01;
+    /**
-    const PERCENT = 0x02;
+     * The performance data value being parsed
-    const BYTES   = 0x04;
+     *
-    const SECONDS = 0x08;
+     * @var string
-
+     */
-    protected $byte_map;
+    protected $perfdataValue;
-
-    protected $min;
-    protected $max;
-    protected $warn;
-    protected $crit;
-    protected $val;
 
+    /**
+     * Unit of measurement (UOM)
+     *
+     * @var string
+     */
     protected $unit;
 
-    public function getFormattedValue()
+    /**
-    {
+     * The value
-        switch ($this->unit) {
+     *
-            case self::BYTES:
+     * @var float
-                return $this->formatBytes() . ' von ' . $this->formatBytes($this->max);
+     */
-                break;
+    protected $value;
-            case self::SECONDS:
-                return $this->formatSeconds();
-                break;
-            case self::PERCENT:
-                return number_format($this->val, 2, ',', '.') . '%';
-                break;
-            default:
-                return $this->val;
-        }
-    }
 
-    public function hasMax()
+    /**
-    {
+     * The minimum value
-        return $this->max !== null && $this->max > 0;
+     *
-    }
+     * @var float
+     */
+    protected $minValue;
 
-    public function getPercentage()
+    /**
-    {
+     * The maximum value
-        if ($this->unit === self::PERCENT) {
+     *
-            return $this->val;
+     * @var float
-        }
+     */
-        if ($this->hasMax()) {
+    protected $maxValue;
-            return $this->val / $this->max * 100;
-        }
-        return false;
-    }
 
-    public function getValue()
+    /**
-    {
+     * The WARNING treshold
-        return $this->val;
+     *
-    }
+     * @var string
+     */
+    protected $warningTreshold;
 
-    protected function formatBytes($val = null)
+    /**
-    {
+     * The CRITICAL treshold
-        $steps = array(
+     *
-            1 => 'Byte',
+     * @var string
-            1024 => 'KByte',
+     */
-            1024 * 1024 => 'MByte',
+    protected $criticalTreshold;
-            1024 * 1024 * 1024 => 'GByte',
-            1024 * 1024 * 1024 * 1024 => 'TByte'
-        );
-        return $this->formatSpecial($steps, 1, $val);
-    }
 
-    protected function formatSeconds()
+    /**
+     * Create a new Perfdata object based on the given performance data value
+     *
+     * @param   string      $perfdataValue      The value to parse
+     */
+    protected function __construct($perfdataValue)
     {
-        $steps = array(
+        $this->perfdataValue = $perfdataValue;
-            1        => 'us',
+        $this->parse();
-            1000     => 'ms',
-            10000000 => 's',
-        );
-        return $this->formatSpecial($steps, 1000000, $this->val);
-    }
 
-    protected function formatSpecial($steps, $multi = 1, $val = null)
+        if ($this->unit === '%') {
-    {
+            if ($this->minValue === null) {
-        if ($val === null) {
+                $this->minValue = 0.0;
-            $val = abs($this->val);
-        } else {
-            $val = abs($val);
-        }
-        // TODO: Check this, prefix fails if $val is given
-        if ($this->val < 0) {
-            $prefix = '-';
-        } else {
-            $prefix = '';
-        }
-        $val *= $multi;
-        $step = 1;
-        foreach (array_keys($steps) as $key) {
-            if ($key > $val * 1) {
-                break;
             }
-            $step = $key;
+            if ($this->maxValue === null) {
-        }
+                $this->maxValue = 100.0;
-	if ($step <= 0) $step = 1;
-        return $prefix
-             . number_format($val / $step, 1, ',', '.')
-            . ' '
-            . $steps[$step];
-    }
-
-    protected function __construct(& $perfdata)
-    {
-        $this->byte_map = array(
-            'b' => 1,
-            'kb' => 1024,
-            'mb' => 1024 * 1024,
-            'gb' => 1024 * 1024 * 1024,
-            'tb' => 1024 * 1024 * 1024 * 1024
-        );
-
-        // UGLY, fixes floats using comma:
-        $perfdata = preg_replace('~\,~', '.', $perfdata);
-
-        $parts = preg_split('~;~', $perfdata, 5);
-        while (count($parts) < 5) {
-            $parts[] = null;
-        }
-        list(
-            $this->val,
-            $this->warn,
-            $this->crit,
-            $this->min,
-            $this->max
-        ) = $parts;
-        // TODO: check numbers!
-
-        $unit = null;
-        if (! preg_match('~^(\-?[\d+\.]+(?:E\-?\d+)?)([^\d]+)?$~', $this->val, $m)) {
-            return $perfdata;
-            // Numbers with an exponential base will be rendered invalid using the regex above
-//            throw new \Exception('Got invalid perfdata: ' . $perfdata);
-        }
-        $this->val  = $m[1];
-        if (isset($m[2])) {
-            $unit = strtolower($m[2]);
-        }
-        if ($unit === 'c') {
-            $this->unit = self::COUNTER;
-        }
-
-        if ($unit === '%') {
-            if (! is_numeric($this->min)) {
-                $this->min = 0;
-            }
-            if (! is_numeric($this->max)) {
-                $this->max = 100;
-            }
-            $this->unit = self::PERCENT;
-        } else {
-            if (! is_numeric($this->max) && $this->crit > 0) {
-                $this->max = $this->crit;
-            }
-        }
-
-        if (array_key_exists($unit, $this->byte_map)) {
-            $this->unit = self::BYTES;
-            $this->val = $this->val * $this->byte_map[$unit];
-            $this->min = $this->min * $this->byte_map[$unit];
-            $this->max = $this->max * $this->byte_map[$unit];
-        }
-        if ($unit === 's') {
-            $this->unit = self::SECONDS;
-        }
-        if ($unit === 'ms') {
-            $this->unit = self::SECONDS;
-            $this->val = $this->val / 1000;
-        }
-        if ($unit === '%') {
-            if (! is_numeric($this->min)) {
-                $this->min = 0;
-            }
-            if (! is_numeric($this->max)) {
-                $this->max = 100;
-            }
-        } else {
-            if (! is_numeric($this->max) && $this->crit > 0) {
-                $this->max = $this->crit;
             }
         }
     }
 
+    /**
+     * Return a new Perfdata object based on the given performance data value
+     *
+     * @param   string      $perfdataValue      The value to parse
+     *
+     * @return  Perfdata
+     *
+     * @throws  ProgrammingError                In case the given performance data value has no content
+     */
+    public static function fromString($perfdataValue)
+    {
+        if (empty($perfdataValue)) {
+            throw new ProgrammingError('Perfdata::fromString expects a string with content');
+        }
+
+        return new static($perfdataValue);
+    }
+
+    /**
+     * Return whether this performance data value is a number
+     *
+     * @return  bool    True in case it's a number, otherwise False
+     */
+    public function isNumber()
+    {
+        return $this->unit === null;
+    }
+
+    /**
+     * Return whether this performance data value are seconds
+     *
+     * @return  bool    True in case it's seconds, otherwise False
+     */
+    public function isSeconds()
+    {
+        return in_array($this->unit, array('s', 'ms', 'us'));
+    }
+
+    /**
+     * Return whether this performance data value is in percentage
+     *
+     * @return  bool    True in case it's in percentage, otherwise False
+     */
+    public function isPercentage()
+    {
+        return $this->unit === '%';
+    }
+
+    /**
+     * Return whether this performance data value is in bytes
+     *
+     * @return  bool    True in case it's in bytes, otherwise False
+     */
+    public function isBytes()
+    {
+        return in_array($this->unit, array('b', 'kb', 'mb', 'gb', 'tb'));
+    }
+
+    /**
+     * Return whether this performance data value is a counter
+     *
+     * @return  bool    True in case it's a counter, otherwise False
+     */
     public function isCounter()
     {
-        return $this->unit === self::COUNTER;
+        return $this->unit === 'c';
     }
 
-    public static function fromString(& $perfdata)
+    /**
+     * Return the value or null if it is unknown (U)
+     *
+     * @return  null|float
+     */
+    public function getValue()
     {
-        $pdat = new Perfdata($perfdata);
+        return $this->value;
-        return $pdat;
     }
 
-    protected function normalizeNumber($num)
+    /**
+     * Return the value as percentage (0-100)
+     *
+     * @return  null|float
+     */
+    public function getPercentage()
     {
-        return $num;
+        if ($this->isPercentage()) {
-        // Bullshit, still TODO
+            return $this->value;
-        /*
+        }
-        $dot = strpos($num, '.');
+
-        $comma = strpos($num, ',');
+        if ($this->maxValue !== null) {
-
+            $minValue = $this->minValue !== null ? $this->minValue : 0;
-        if ($dot === false) {
+
-            // No dot...
+            if ($this->value > $minValue) {
-            if ($comma === false) {
+                return (($this->value - $minValue) / ($this->maxValue - $minValue)) * 100;
-                // ...and no comma, it's an integer:
+            }
-                return (int) $num;
+        }
-            } else {
+    }
-                // just a comma
+
-            }
+    /**
-        } else {
+     * Return this value's warning treshold or null if it is not available
-            if ($comma === false) {
+     *
+     * @return  null|string
+     */
+    public function getWarningTreshold()
+    {
+        return $this->warningTreshold;
+    }
+
+    /**
+     * Return this value's critical treshold or null if it is not available
+     *
+     * @return  null|string
+     */
+    public function getCriticalTreshold()
+    {
+        return $this->criticalTreshold;
+    }
+
+    /**
+     * Return the minimum value or null if it is not available
+     *
+     * @return  null|float
+     */
+    public function getMinimumValue()
+    {
+        return $this->minValue;
+    }
+
+    /**
+     * Return the maximum value or null if it is not available
+     *
+     * @return  null|float
+     */
+    public function getMaximumValue()
+    {
+        return $this->maxValue;
+    }
+
+    /**
+     * Parse the current performance data value
+     *
+     * @todo    Handle optional min/max if UOM == %
+     */
+    protected function parse()
+    {
+        $parts = explode(';', $this->perfdataValue);
+
+        $matches = array();
+        if (preg_match('@^(\d+(\.\d+)?)([a-zA-Z%]{1,2})$@', $parts[0], $matches)) {
+            $this->unit = strtolower($matches[3]);
+            $this->value = self::convert($matches[1], $this->unit);
+        } else {
+            $this->value = self::convert($parts[0]);
+        }
+
+        switch (count($parts))
+        {
+            case 5:
+                $this->maxValue = self::convert($parts[4], $this->unit);
+            case 4:
+                $this->minValue = self::convert($parts[3], $this->unit);
+            case 3:
+                // TODO(#6123): Tresholds have the same UOM and need to be converted as well!
+                $this->criticalTreshold = trim($parts[2]) ? trim($parts[2]) : null;
+            case 2:
+                // TODO(#6123): Tresholds have the same UOM and need to be converted as well!
+                $this->warningTreshold = trim($parts[1]) ? trim($parts[1]) : null;
+        }
+    }
+
+    /**
+     * Return the given value converted to its smallest supported representation
+     *
+     * @param   string      $value      The value to convert
+     * @param   string      $fromUnit   The unit the value currently represents
+     *
+     * @return  null|float              Null in case the value is not a number
+     */
+    protected static function convert($value, $fromUnit = null)
+    {
+        if (is_numeric($value)) {
+            switch ($fromUnit)
+            {
+                case 'us':
+                    return $value / pow(10, 6);
+                case 'ms':
+                    return $value / pow(10, 3);
+                case 'tb':
+                    return floatval($value) * pow(2, 40);
+                case 'gb':
+                    return floatval($value) * pow(2, 30);
+                case 'mb':
+                    return floatval($value) * pow(2, 20);
+                case 'kb':
+                    return floatval($value) * pow(2, 10);
+                default:
+                    return (float) $value;
+            }
         }
-        */
     }
 }

modules/monitoring/library/Monitoring/Plugin/PerfdataSet.php

@@ -1,68 +1,144 @@
 <?php
+// {{{ICINGA_LICENSE_HEADER}}}
+// {{{ICINGA_LICENSE_HEADER}}}
 
 namespace Icinga\Module\Monitoring\Plugin;
 
-class PerfdataSet
+use ArrayIterator;
-{
+use IteratorAggregate;
-    protected $ptr;
-    protected $pos = 0;
-    protected $len;
-    protected $perfdata;
 
-    protected function __construct($perfdata)
+class PerfdataSet implements IteratorAggregate
+{
+    /**
+     * The performance data being parsed
+     *
+     * @var string
+     */
+    protected $perfdataStr;
+
+    /**
+     * The current parsing position
+     *
+     * @var int
+     */
+    protected $parserPos = 0;
+
+    /**
+     * A list of Perfdata objects
+     *
+     * @var array
+     */
+    protected $perfdata = array();
+
+    /**
+     * Create a new set of performance data
+     *
+     * @param   string      $perfdataStr    A space separated list of label/value pairs
+     */
+    protected function __construct($perfdataStr)
     {
-        if (empty($perfdata)) return;
+        if (($perfdataStr = trim($perfdataStr)) !== '') {
-        $this->ptr = & $perfdata;
+            $this->perfdataStr = $perfdataStr;
-        $this->len = strlen($this->ptr);
+            $this->parse();
-        while ($this->pos < $this->len) {
-            $label = $this->readLabel();
-            $perf  = $this->readUntil(' ');
-            if (empty($perf)) continue;
-            $this->perfdata[$label] = Perfdata::fromString($perf);
         }
     }
 
-    public static function fromString(& $perfdata)
+    /**
+     * Return a iterator for this set of performance data
+     *
+     * @return  ArrayIterator
+     */
+    public function getIterator()
     {
-        $pset = new PerfdataSet($perfdata);
+        return new ArrayIterator($this->asArray());
-        return $pset;
     }
 
-    public function getAll()
+    /**
+     * Return a new set of performance data
+     *
+     * @param   string      $perfdataStr    A space separated list of label/value pairs
+     *
+     * @return  PerfdataSet
+     */
+    public static function fromString($perfdataStr)
     {
-        return $this->perfdata === null ? array() : $this->perfdata;
+        return new static($perfdataStr);
     }
 
+    /**
+     * Return this set of performance data as array
+     *
+     * @return  array
+     */
+    public function asArray()
+    {
+        return $this->perfdata;
+    }
+
+    /**
+     * Parse the current performance data
+     */
+    protected function parse()
+    {
+        while ($this->parserPos < strlen($this->perfdataStr)) {
+            $label = trim($this->readLabel());
+            $value = trim($this->readUntil(' '));
+
+            if ($label && $value) {
+                $this->perfdata[$label] = Perfdata::fromString($value);
+            }
+        }
+    }
+
+    /**
+     * Return the next label found in the performance data
+     *
+     * @return  string      The label found
+     */
     protected function readLabel()
     {
         $this->skipSpaces();
-        if (in_array($this->ptr[$this->pos], array('"', "'"))) {
+        if (in_array($this->perfdataStr[$this->parserPos], array('"', "'"))) {
-            $this->pos++;
+            $quoteChar = $this->perfdataStr[$this->parserPos++];
-            $label = $this->readUntil($this->ptr[$this->pos - 1]);
+            $label = $this->readUntil('=');
-            $this->pos++; // Skip ' or "
+            $this->parserPos++;
-            $skip = $this->readUntil('=');
+
-            $this->pos++;
+            if (($closingPos = strpos($label, $quoteChar)) > 0) {
+                $label = substr($label, 0, $closingPos);
+            }
         } else {
             $label = $this->readUntil('=');
-            $this->pos++;
+            $this->parserPos++;
         }
+
         $this->skipSpaces();
-        return trim($label);
+        return $label;
     }
 
-    protected function readUntil($stop_char)
+    /**
+     * Return all characters between the current parser position and the given character
+     *
+     * @param   string  $stopChar   The character on which to stop
+     *
+     * @return  string
+     */
+    protected function readUntil($stopChar)
     {
-        $start = $this->pos;
+        $start = $this->parserPos;
-        while ($this->pos < $this->len && $this->ptr[$this->pos] !== $stop_char) {
+        while ($this->parserPos < strlen($this->perfdataStr) && $this->perfdataStr[$this->parserPos] !== $stopChar) {
-            $this->pos++;
+            $this->parserPos++;
         }
-        return substr($this->ptr, $start, $this->pos - $start);
+
+        return substr($this->perfdataStr, $start, $this->parserPos - $start);
     }
 
+    /**
+     * Advance the parser position to the next non-whitespace character
+     */
     protected function skipSpaces()
     {
-        while ($this->pos < $this->len && $this->ptr[$this->pos] === ' ') {
+        while ($this->parserPos < strlen($this->perfdataStr) && $this->perfdataStr[$this->parserPos] === ' ') {
-            $this->pos++;
+            $this->parserPos++;
         }
     }
 }

modules/monitoring/test/php/library/Monitoring/Filter/Type/StatusFilterTest.php

@@ -2,7 +2,7 @@
 // {{{ICINGA_LICENSE_HEADER}}}
 // {{{ICINGA_LICENSE_HEADER}}}
 
-namespace Tests\Icinga\Module\Monitoring\Library\Filter\Type;
+namespace Tests\Icinga\Module\Monitoring\Filter\Type;
 
 use Icinga\Module\Monitoring\Filter\Type\StatusFilter;
 use Icinga\Filter\Type\TimeRangeSpecifier;

modules/monitoring/test/php/library/Monitoring/Filter/UrlViewFilterTest.php

@@ -2,7 +2,7 @@
 // {{{ICINGA_LICENSE_HEADER}}}
 // {{{ICINGA_LICENSE_HEADER}}}
 
-namespace Tests\Icinga\Module\Monitoring\Library\Filter;
+namespace Tests\Icinga\Module\Monitoring\Filter;
 
 use \Mockery;
 use Icinga\Module\Monitoring\Filter\Type\StatusFilter;

modules/monitoring/test/php/library/Monitoring/Plugin/PerfdataSetTest.php

@@ -0,0 +1,101 @@
+<?php
+// {{{ICINGA_LICENSE_HEADER}}}
+// {{{ICINGA_LICENSE_HEADER}}}
+
+namespace Tests\Icinga\Module\Monitoring\Plugin;
+
+use Icinga\Test\BaseTestCase;
+use Icinga\Module\Monitoring\Plugin\PerfdataSet;
+
+class PerfdataSetWithPublicData extends PerfdataSet
+{
+    public $perfdata = array();
+}
+
+class PerfdataSetTest extends BaseTestCase
+{
+    public function testWhetherValidSimplePerfdataLabelsAreProperlyParsed()
+    {
+        $pset = PerfdataSetWithPublicData::fromString('key1=val1   key2=val2 key3  =val3');
+        $this->assertArrayHasKey(
+            'key1',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse valid simple labels'
+        );
+        $this->assertArrayHasKey(
+            'key2',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse valid simple labels'
+        );
+        $this->assertArrayHasKey(
+            'key3',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse valid simple labels'
+        );
+    }
+
+    public function testWhetherNonQuotedPerfdataLablesWithSpacesAreProperlyParsed()
+    {
+        $pset = PerfdataSetWithPublicData::fromString('key 1=val1 key 1 + 1=val2');
+        $this->assertArrayHasKey(
+            'key 1',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse non quoted labels with spaces'
+        );
+        $this->assertArrayHasKey(
+            'key 1 + 1',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse non quoted labels with spaces'
+        );
+    }
+
+    public function testWhetherValidQuotedPerfdataLabelsAreProperlyParsed()
+    {
+        $pset = PerfdataSetWithPublicData::fromString('\'key 1\'=val1 "key 2"=val2');
+        $this->assertArrayHasKey(
+            'key 1',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse valid quoted labels'
+        );
+        $this->assertArrayHasKey(
+            'key 2',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse valid quoted labels'
+        );
+    }
+
+    public function testWhetherInvalidQuotedPerfdataLabelsAreProperlyParsed()
+    {
+        $pset = PerfdataSetWithPublicData::fromString('\'key 1=val1 key 2"=val2');
+        $this->assertArrayHasKey(
+            'key 1',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse invalid quoted labels'
+        );
+        $this->assertArrayHasKey(
+            'key 2"',
+            $pset->perfdata,
+            'PerfdataSet does not correctly parse invalid quoted labels'
+        );
+    }
+
+    /**
+     * @depends testWhetherValidSimplePerfdataLabelsAreProperlyParsed
+     */
+    public function testWhetherAPerfdataSetIsIterable()
+    {
+        $pset = PerfdataSet::fromString('key=value');
+        foreach ($pset as $label => $value) {
+            $this->assertEquals('key', $label);
+            return;
+        }
+
+        $this->fail('PerfdataSet objects cannot be iterated');
+    }
+
+    public function testWhetherPerfdataSetsCanBeInitializedWithEmptyStrings()
+    {
+        $pset = PerfdataSetWithPublicData::fromString('');
+        $this->assertEmpty($pset->perfdata, 'PerfdataSet::fromString does not accept emtpy strings');
+    }
+}

modules/monitoring/test/php/library/Monitoring/Plugin/PerfdataTest.php

@@ -0,0 +1,352 @@
+<?php
+// {{{ICINGA_LICENSE_HEADER}}}
+// {{{ICINGA_LICENSE_HEADER}}}
+
+namespace Tests\Icinga\Module\Monitoring\Plugin;
+
+use Icinga\Test\BaseTestCase;
+use Icinga\Module\Monitoring\Plugin\Perfdata;
+
+class PerfdataTest extends BaseTestCase
+{
+    /**
+     * @expectedException   Icinga\Exception\ProgrammingError
+     */
+    public function testWhetherFromStringThrowsExceptionWhenGivenAnEmptyString()
+    {
+        Perfdata::fromString('');
+    }
+
+    public function testWhetherGetValueReturnsValidValues()
+    {
+        $this->assertEquals(
+            1337.0,
+            Perfdata::fromString('1337')->getValue(),
+            'Perfdata::getValue does not return correct values'
+        );
+        $this->assertEquals(
+            1337.0,
+            Perfdata::fromString('1337;;;;')->getValue(),
+            'Perfdata::getValue does not return correct values'
+        );
+    }
+
+    public function testWhetherDecimalValuesAreCorrectlyParsed()
+    {
+        $this->assertEquals(
+            1337.5,
+            Perfdata::fromString('1337.5')->getValue(),
+            'Perfdata objects do not parse decimal values correctly'
+        );
+        $this->assertEquals(
+            1337.5,
+            Perfdata::fromString('1337.5B')->getValue(),
+            'Perfdata objects do not parse decimal values correctly'
+        );
+    }
+
+    public function testWhetherGetValueReturnsNullForInvalidOrUnknownValues()
+    {
+        $this->assertNull(
+            Perfdata::fromString('U')->getValue(),
+            'Perfdata::getValue does not return null for unknown values'
+        );
+        $this->assertNull(
+            Perfdata::fromString('i am not a value')->getValue(),
+            'Perfdata::getValue does not return null for invalid values'
+        );
+    }
+
+    public function testWhetherGetWarningTresholdReturnsCorrectValues()
+    {
+        $this->assertEquals(
+            '10',
+            Perfdata::fromString('1;10')->getWarningTreshold(),
+            'Perfdata::getWarningTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '10:',
+            Perfdata::fromString('1;10:')->getWarningTreshold(),
+            'Perfdata::getWarningTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '~:10',
+            Perfdata::fromString('1;~:10')->getWarningTreshold(),
+            'Perfdata::getWarningTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '10:20',
+            Perfdata::fromString('1;10:20')->getWarningTreshold(),
+            'Perfdata::getWarningTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '@10:20',
+            Perfdata::fromString('1;@10:20')->getWarningTreshold(),
+            'Perfdata::getWarningTreshold does not return correct values'
+        );
+    }
+
+    public function testWhetherGetCriticalTresholdReturnsCorrectValues()
+    {
+        $this->assertEquals(
+            '10',
+            Perfdata::fromString('1;;10')->getCriticalTreshold(),
+            'Perfdata::getCriticalTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '10:',
+            Perfdata::fromString('1;;10:')->getCriticalTreshold(),
+            'Perfdata::getCriticalTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '~:10',
+            Perfdata::fromString('1;;~:10')->getCriticalTreshold(),
+            'Perfdata::getCriticalTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '10:20',
+            Perfdata::fromString('1;;10:20')->getCriticalTreshold(),
+            'Perfdata::getCriticalTreshold does not return correct values'
+        );
+        $this->assertEquals(
+            '@10:20',
+            Perfdata::fromString('1;;@10:20')->getCriticalTreshold(),
+            'Perfdata::getCriticalTreshold does not return correct values'
+        );
+    }
+
+    public function testWhetherGetMinimumValueReturnsCorrectValues()
+    {
+        $this->assertEquals(
+            1337.0,
+            Perfdata::fromString('1;;;1337')->getMinimumValue(),
+            'Perfdata::getMinimumValue does not return correct values'
+        );
+        $this->assertEquals(
+            1337.5,
+            Perfdata::fromString('1;;;1337.5')->getMinimumValue(),
+            'Perfdata::getMinimumValue does not return correct values'
+        );
+    }
+
+    public function testWhetherGetMaximumValueReturnsCorrectValues()
+    {
+        $this->assertEquals(
+            1337.0,
+            Perfdata::fromString('1;;;;1337')->getMaximumValue(),
+            'Perfdata::getMaximumValue does not return correct values'
+        );
+        $this->assertEquals(
+            1337.5,
+            Perfdata::fromString('1;;;;1337.5')->getMaximumValue(),
+            'Perfdata::getMaximumValue does not return correct values'
+        );
+    }
+
+    public function testWhetherMissingValuesAreReturnedAsNull()
+    {
+        $perfdata = Perfdata::fromString('1;;3;5');
+        $this->assertNull(
+            $perfdata->getWarningTreshold(),
+            'Perfdata objects do not return null for missing warning tresholds'
+        );
+        $this->assertNull(
+            $perfdata->getMaximumValue(),
+            'Perfdata objects do not return null for missing maximum values'
+        );
+    }
+
+    /**
+     * @depends testWhetherGetValueReturnsValidValues
+     */
+    public function testWhetherValuesAreIdentifiedAsNumber()
+    {
+        $this->assertTrue(
+            Perfdata::fromString('666')->isNumber(),
+            'Perfdata objects do not identify ordinary digits as number'
+        );
+    }
+
+    /**
+     * @depends testWhetherGetValueReturnsValidValues
+     */
+    public function testWhetherValuesAreIdentifiedAsSeconds()
+    {
+        $this->assertTrue(
+            Perfdata::fromString('666s')->isSeconds(),
+            'Perfdata objects do not identify seconds as seconds'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('666us')->isSeconds(),
+            'Perfdata objects do not identify microseconds as seconds'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('666ms')->isSeconds(),
+            'Perfdata objects do not identify milliseconds as seconds'
+        );
+    }
+
+    /**
+     * @depends testWhetherGetValueReturnsValidValues
+     */
+    public function testWhetherValuesAreIdentifiedAsPercentage()
+    {
+        $this->assertTrue(
+            Perfdata::fromString('66%')->isPercentage(),
+            'Perfdata objects do not identify percentages as percentages'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsPercentage
+     */
+    public function testWhetherMinAndMaxAreNotRequiredIfUnitIsInPercent()
+    {
+        $perfdata = Perfdata::fromString('1%');
+        $this->assertEquals(
+            0.0,
+            $perfdata->getMinimumValue(),
+            'Perfdata objects do not set minimum value to 0 if UOM is %'
+        );
+        $this->assertEquals(
+            100.0,
+            $perfdata->getMaximumValue(),
+            'Perfdata objects do not set maximum value to 100 if UOM is %'
+        );
+    }
+
+    /**
+     * @depends testWhetherGetValueReturnsValidValues
+     */
+    public function testWhetherValuesAreIdentifiedAsBytes()
+    {
+        $this->assertTrue(
+            Perfdata::fromString('66666B')->isBytes(),
+            'Perfdata objects do not identify bytes as bytes'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('6666KB')->isBytes(),
+            'Perfdata objects do not identify kilobytes as bytes'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('666MB')->isBytes(),
+            'Perfdata objects do not identify megabytes as bytes'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('66GB')->isBytes(),
+            'Perfdata objects do not identify gigabytes as bytes'
+        );
+        $this->assertTrue(
+            Perfdata::fromString('6TB')->isBytes(),
+            'Perfdata objects do not identify terabytes as bytes'
+        );
+    }
+
+    /**
+     * @depends testWhetherGetValueReturnsValidValues
+     */
+    public function testWhetherValuesAreIdentifiedAsCounter()
+    {
+        $this->assertTrue(
+            Perfdata::fromString('123c')->isCounter(),
+            'Perfdata objects do not identify counters as counters'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsSeconds
+     */
+    public function testWhetherMicroSecondsAreCorrectlyConvertedToSeconds()
+    {
+        $this->assertEquals(
+            666 / pow(10, 6),
+            Perfdata::fromString('666us')->getValue(),
+            'Perfdata objects do not correctly convert microseconds to seconds'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsSeconds
+     */
+    public function testWhetherMilliSecondsAreCorrectlyConvertedToSeconds()
+    {
+        $this->assertEquals(
+            666 / pow(10, 3),
+            Perfdata::fromString('666ms')->getValue(),
+            'Perfdata objects do not correctly convert microseconds to seconds'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsPercentage
+     */
+    public function testWhetherPercentagesAreHandledCorrectly()
+    {
+        $this->assertEquals(
+            66.0,
+            Perfdata::fromString('66%')->getPercentage(),
+            'Perfdata objects do not correctly handle native percentages'
+        );
+        $this->assertEquals(
+            50.0,
+            Perfdata::fromString('0;;;-250;250')->getPercentage(),
+            'Perfdata objects do not correctly convert suitable values to percentages'
+        );
+        $this->assertNull(
+            Perfdata::fromString('50')->getPercentage(),
+            'Perfdata objects do return a percentage though their unit is not % and no maximum is given'
+        );
+        $this->assertNull(
+            Perfdata::fromString('25;;;50;100')->getPercentage(),
+            'Perfdata objects do return a percentage though their value is lower than it\'s allowed minimum'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsBytes
+     */
+    public function testWhetherKiloBytesAreCorrectlyConvertedToBytes()
+    {
+        $this->assertEquals(
+            6666.0 * pow(2, 10),
+            Perfdata::fromString('6666KB')->getValue(),
+            'Perfdata objects do not corretly convert kilobytes to bytes'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsBytes
+     */
+    public function testWhetherMegaBytesAreCorrectlyConvertedToBytes()
+    {
+        $this->assertEquals(
+            666.0 * pow(2, 20),
+            Perfdata::fromString('666MB')->getValue(),
+            'Perfdata objects do not corretly convert megabytes to bytes'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsBytes
+     */
+    public function testWhetherGigaBytesAreCorrectlyConvertedToBytes()
+    {
+        $this->assertEquals(
+            66.0 * pow(2, 30),
+            Perfdata::fromString('66GB')->getValue(),
+            'Perfdata objects do not corretly convert gigabytes to bytes'
+        );
+    }
+
+    /**
+     * @depends testWhetherValuesAreIdentifiedAsBytes
+     */
+    public function testWhetherTeraBytesAreCorrectlyConvertedToBytes()
+    {
+        $this->assertEquals(
+            6.0 * pow(2, 40),
+            Perfdata::fromString('6TB')->getValue(),
+            'Perfdata objects do not corretly convert terabytes to bytes'
+        );
+    }
+}

public/js/icinga/loader.js

@@ -508,7 +508,7 @@
                 // Icinga.debug(req.getResponseHeader('X-Icinga-Redirect'));
             } else {
                 if (errorThrown === 'abort') {
-                    this.icinga.logger.info(
+                    this.icinga.logger.debug(
                         'Request to ' + url + ' has been aborted for ',
                         req.$target
                     );