Report::getMinItemTime() - Code Metrics - caseyamcl/tasktracker - Measure and Improve Code Quality continuously with Scrutinizer

Report::getMinItemTime() A
last analyzed 2019-04-11 19:04 UTC

↳ Parent: Report

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/**
 * Tack Tracker - A library for tracking long-running task progress
 *
 * @license http://opensource.org/licenses/MIT
 * @link https://github.com/caseyamcl/tasktracker
 * @version 2.0
 * @package caseyamcl/tasktracker
 * @author Casey McLaughlin <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * ------------------------------------------------------------------
 */

namespace TaskTracker;

use TaskTracker\Helper\MagicPropsTrait;

/**
 * Task Tracker Report
 *
 * Represents a snapshot of task state from a specific time*
 *
 * @author Casey McLaughlin <[email protected]>
 */
class Report implements ReportInterface
{
    use MagicPropsTrait {
        toArray as traitToArray;
    }

    /**
     * @var Tick
     */
    private $tick;

    /**
     * @var Tracker
     */
    private $tracker;

    /**
     * @var int
     */
    private $memUsage;

    /**
     * @var int
     */
    private $memPeakUsage;

    /**
     * @var float
     */
    private $itemTime;

    /**
     * @var float
     */
    private $maxTickTime;

    /**
     * @var float
     */
    private $minTickTime;

    /**
     * Constructor
     *
     * @param Tick      $tick     Empty if no tick yet
     * @param Tracker   $tracker  The Task Tracker
     */
    public function __construct(Tick $tick, Tracker $tracker)
    {
        $this->tick    = $tick;
        $this->tracker = $tracker;

        // A snapshot of these values needs to be created upon report generation
        $this->memUsage     = memory_get_usage(true);
        $this->memPeakUsage = memory_get_peak_usage(true);

        // Also, determining item time values needs to happen immediately
        $this->itemTime = ($this->tracker->getLastTick())
            ? $this->tick->getTimestamp() - $this->tracker->getLastTick()->getTimestamp()
            : $this->getTimeElapsed();

        if ($this->tracker->getLastTick()) {
            $this->minTickTime = min($this->getItemTime(), $this->tracker->getLastTick()->getReport()->getMinItemTime());
            $this->maxTickTime = max($this->getItemTime(), $this->tracker->getLastTick()->getReport()->getMaxItemTime());
        }
        else {
            $this->minTickTime = $this->minTickTime = $this->getItemTime();
            $this->maxTickTime = $this->minTickTime = $this->getItemTime();
        }
    }

    /**
     * Returns the time this task started in microseconds
     *
     * @return float
     */
    public function getTimeStarted()
    {
        return $this->tracker->getStartTime();
    }

    /**
     * Returns the total number of items that are to be processed.
     *
     * If unknown or not specified, this returns Tracker::UNKNOWN
     *
     * @return int
     */
    public function getTotalItemCount()
    {
        return $this->tracker->getNumTotalItems();
    }

    /**
     * Get the Tracker Tick object for this report
     *
     * @return Tick
     */
    public function getTick()
    {
        return $this->tick;
    }

    /**
     * Returns the total number of items processed (including skipped and failed)
     *
     * @return int
     */
    public function getNumItemsProcessed()
    {
        return $this->tracker->getNumProcessedItems();
    }

    /**
     * Returns the time elapsed in microseconds
     *
     * @return float
     */
    public function getTimeElapsed()
    {
        return $this->tick->getTimestamp() - $this->tracker->getStartTime();
    }


    /**
     * Returns the number of items thus far that successfully processed
     *
     * @return int
     */
    public function getNumItemsSuccess()
    {
        return $this->tracker->getNumProcessedItems(Tick::SUCCESS);
    }

    /**
     * Returns the number of items processed thus far that failed
     *
     * @return int
     */
    public function getNumItemsFail()
    {
        return $this->tracker->getNumProcessedItems(Tick::FAIL);
    }

    /**
     * Returns the number of items processed thus far that were skipped
     *
     * @return int
     */
    public function getNumItemsSkip()
    {
        return $this->tracker->getNumProcessedItems(Tick::SKIP);
    }

    /**
     * Returns the amount of time the last item took to process
     *
     * @return float
     */
    public function getItemTime()
    {
        return $this->itemTime;
    }

    /**
     * Returns the maximum amount of time any one item has taken to process thus far
     *
     * @return float
     */
    public function getMaxItemTime()
    {
        return $this->maxTickTime;
    }

    /**
     * Returns the minimum amount of time any one item has taken to process thus far
     *
     * @return float
     */
    public function getMinItemTime()
    {
        return $this->minTickTime;
    }

    /**
     * Returns the current average (mean) amount of time that items have taken to process thus far
     *
     * @return float
     */
    public function getAvgItemTime()
    {
        return ($this->getNumItemsProcessed() > 0)
            ? ($this->getTimeElapsed() / $this->getNumItemsProcessed())
            : 0;
    }

    /**
     * Returns the message associated with the last Tick event
     *
     * @return string
     */
    public function getMessage()
    {
        return $this->tick->getMessage();
    }

    /**
     * Returns the timestamp (microtime float) for this Tick event
     *
     * @return float
     */
    public function getTimestamp()
    {
        return $this->tick->getTimestamp();
    }

    /**
     * Returns the status (Tick::SUCCESS, Tick::FAIL, TICK::SKIP) of the last item processed
     *
     * @return int
     */
    public function getStatus()
    {
        return $this->tick->getStatus();
    }

    /**
     * Returns the number of increments associated with the last processed item
     *
     * @return int
     */
    public function getIncrementBy()
    {
        return $this->tick->getIncrementBy();
    }

    /**
     * Returns the memory usage at the time of the last processed item (in bytes)
     *
     * @return int
     */
    public function getMemUsage()
    {
        return $this->memUsage;
    }

    /**
     * Returns the peak memory usage thus far
     *
     * @return int
     */
    public function getMemPeakUsage()
    {
        return $this->memPeakUsage;
    }

    /**
     * Returns this report
     *
     * @return Report
     */
    public function getReport()
    {
        return $this;
    }

    /**
     * Returns any extra information associated with the last tick
     *
     * @return array
     */
    public function getExtraInfo()
    {
        return $this->tick->getExtraInfo();
    }

    /**
     * Converts this report to an array
     *
     * @return array
     */
    public function toArray()
    {
        $arr = $this->traitToArray();
        unset($arr['report'], $arr['tick']);
        return $arr;
    }
}


1			<?php
2
3			/**
4			* Tack Tracker - A library for tracking long-running task progress
5			*
6			* @license http://opensource.org/licenses/MIT
7			* @link https://github.com/caseyamcl/tasktracker
8			* @version 2.0
9			* @package caseyamcl/tasktracker
10			* @author Casey McLaughlin <[email protected]>
11			*
12			* For the full copyright and license information, please view the LICENSE
13			* file that was distributed with this source code.
14			*
15			* ------------------------------------------------------------------
16			*/
17
18			namespace TaskTracker;
19
20			use TaskTracker\Helper\MagicPropsTrait;
21
22			/**
23			* Task Tracker Report
24			*
25			* Represents a snapshot of task state from a specific time*
26			*
27			* @author Casey McLaughlin <[email protected]>
28			*/
29			class Report implements ReportInterface
30			{
31			use MagicPropsTrait {
32			toArray as traitToArray;
33			}
34
35			/**
36			* @var Tick
37			*/
38			private $tick;
39
40			/**
41			* @var Tracker
42			*/
43			private $tracker;
44
45			/**
46			* @var int
47			*/
48			private $memUsage;
49
50			/**
51			* @var int
52			*/
53			private $memPeakUsage;
54
55			/**
56			* @var float
57			*/
58			private $itemTime;
59
60			/**
61			* @var float
62			*/
63			private $maxTickTime;
64
65			/**
66			* @var float
67			*/
68			private $minTickTime;
69
70			/**
71			* Constructor
72			*
73			* @param Tick $tick Empty if no tick yet
74			* @param Tracker $tracker The Task Tracker
75			*/
76			public function __construct(Tick $tick, Tracker $tracker)
77			{
78			$this->tick = $tick;
79			$this->tracker = $tracker;
80
81			// A snapshot of these values needs to be created upon report generation
82			$this->memUsage = memory_get_usage(true);
83			$this->memPeakUsage = memory_get_peak_usage(true);
84
85			// Also, determining item time values needs to happen immediately
86			$this->itemTime = ($this->tracker->getLastTick())
87			? $this->tick->getTimestamp() - $this->tracker->getLastTick()->getTimestamp()
88			: $this->getTimeElapsed();
89
90			if ($this->tracker->getLastTick()) {
91			$this->minTickTime = min($this->getItemTime(), $this->tracker->getLastTick()->getReport()->getMinItemTime());
92			$this->maxTickTime = max($this->getItemTime(), $this->tracker->getLastTick()->getReport()->getMaxItemTime());
93			}
94			else {
95			$this->minTickTime = $this->minTickTime = $this->getItemTime();
96			$this->maxTickTime = $this->minTickTime = $this->getItemTime();
97			}
98			}
99
100			/**
101			* Returns the time this task started in microseconds
102			*
103			* @return float
104			*/
105			public function getTimeStarted()
106			{
107			return $this->tracker->getStartTime();
108			}
109
110			/**
111			* Returns the total number of items that are to be processed.
112			*
113			* If unknown or not specified, this returns Tracker::UNKNOWN
114			*
115			* @return int
116			*/
117			public function getTotalItemCount()
118			{
119			return $this->tracker->getNumTotalItems();
120			}
121
122			/**
123			* Get the Tracker Tick object for this report
124			*
125			* @return Tick
126			*/
127			public function getTick()
128			{
129			return $this->tick;
130			}
131
132			/**
133			* Returns the total number of items processed (including skipped and failed)
134			*
135			* @return int
136			*/
137			public function getNumItemsProcessed()
138			{
139			return $this->tracker->getNumProcessedItems();
140			}
141
142			/**
143			* Returns the time elapsed in microseconds
144			*
145			* @return float
146			*/
147			public function getTimeElapsed()
148			{
149			return $this->tick->getTimestamp() - $this->tracker->getStartTime();
150			}
151
152
153			/**
154			* Returns the number of items thus far that successfully processed
155			*
156			* @return int
157			*/
158			public function getNumItemsSuccess()
159			{
160			return $this->tracker->getNumProcessedItems(Tick::SUCCESS);
161			}
162
163			/**
164			* Returns the number of items processed thus far that failed
165			*
166			* @return int
167			*/
168			public function getNumItemsFail()
169			{
170			return $this->tracker->getNumProcessedItems(Tick::FAIL);
171			}
172
173			/**
174			* Returns the number of items processed thus far that were skipped
175			*
176			* @return int
177			*/
178			public function getNumItemsSkip()
179			{
180			return $this->tracker->getNumProcessedItems(Tick::SKIP);
181			}
182
183			/**
184			* Returns the amount of time the last item took to process
185			*
186			* @return float
187			*/
188			public function getItemTime()
189			{
190			return $this->itemTime;
191			}
192
193			/**
194			* Returns the maximum amount of time any one item has taken to process thus far
195			*
196			* @return float
197			*/
198			public function getMaxItemTime()
199			{
200			return $this->maxTickTime;
201			}
202
203			/**
204			* Returns the minimum amount of time any one item has taken to process thus far
205			*
206			* @return float
207			*/
208			public function getMinItemTime()
209			{
210			return $this->minTickTime;
211			}
212
213			/**
214			* Returns the current average (mean) amount of time that items have taken to process thus far
215			*
216			* @return float
217			*/
218			public function getAvgItemTime()
219			{
220			return ($this->getNumItemsProcessed() > 0)
221			? ($this->getTimeElapsed() / $this->getNumItemsProcessed())
222			: 0;
223			}
224
225			/**
226			* Returns the message associated with the last Tick event
227			*
228			* @return string
229			*/
230			public function getMessage()
231			{
232			return $this->tick->getMessage();
233			}
234
235			/**
236			* Returns the timestamp (microtime float) for this Tick event
237			*
238			* @return float
239			*/
240			public function getTimestamp()
241			{
242			return $this->tick->getTimestamp();
243			}
244
245			/**
246			* Returns the status (Tick::SUCCESS, Tick::FAIL, TICK::SKIP) of the last item processed
247			*
248			* @return int
249			*/
250			public function getStatus()
251			{
252			return $this->tick->getStatus();
253			}
254
255			/**
256			* Returns the number of increments associated with the last processed item
257			*
258			* @return int
259			*/
260			public function getIncrementBy()
261			{
262			return $this->tick->getIncrementBy();
263			}
264
265			/**
266			* Returns the memory usage at the time of the last processed item (in bytes)
267			*
268			* @return int
269			*/
270			public function getMemUsage()
271			{
272			return $this->memUsage;
273			}
274
275			/**
276			* Returns the peak memory usage thus far
277			*
278			* @return int
279			*/
280			public function getMemPeakUsage()
281			{
282			return $this->memPeakUsage;
283			}
284
285			/**
286			* Returns this report
287			*
288			* @return Report
289			*/
290			public function getReport()
291			{
292			return $this;
293			}
294
295			/**
296			* Returns any extra information associated with the last tick
297			*
298			* @return array
299			*/
300			public function getExtraInfo()
301			{
302			return $this->tick->getExtraInfo();
303			}
304
305			/**
306			* Converts this report to an array
307			*
308			* @return array
309			*/
310			public function toArray()
311			{
312			$arr = $this->traitToArray();
313			unset($arr['report'], $arr['tick']);
314			return $arr;
315			}
316			}
317

caseyamcl / tasktracker

Report::getMinItemTime() A last analyzed 2019-04-11 19:04 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Report::getMinItemTime() A
last analyzed 2019-04-11 19:04 UTC