/**
* @param $event
* @param $parameters
*
* @return mixed|void
*/
public function emit($event, $parameters)
{
self::$depth++;
$this->stopwatch->openSection();
if (isset($this->callbacks[$event])) {
if (!$this->callbacks[$event][0]) {
usort($this->callbacks[$event][1], function ($A, $B) {
if ($A[0] == $B[0]) {
return 0;
}
return $A[0] > $B[0] ? 1 : -1;
});
$this->callbacks[$event][0] = true;
}
foreach ($this->callbacks[$event][1] as $item) {
$name = $this->getCallableName($item[1]);
$this->stopwatch->start($name);
$diagnoseEvent = Event::create()->setEvent($event)->setCallback($name)->setDepth(self::$depth);
$this->events[] = $diagnoseEvent;
call_user_func_array($item[1], $this->buildParameters($parameters));
$stopwatchEvent = $this->stopwatch->stop($name);
$diagnoseEvent->setDuration($stopwatchEvent->getDuration())->setMemory($stopwatchEvent->getMemory());
}
}
$this->stopwatch->stopSection($event);
self::$depth--;
}
/**
* @param $url
* @param array $arguments
* @param string $uniqueId
*
* @throws \Exception
*
* @return string
*/
public function rasterizeUrl($url, $arguments = array(), $uniqueId = "")
{
if ($uniqueId === "") {
$uniqueId = uniqid("rasterize-");
}
if ($this->stopwatch instanceof Stopwatch) {
if ($this->stopwatch->isStarted($uniqueId)) {
$this->stopwatch->lap($uniqueId);
} else {
$this->stopwatch->start($uniqueId);
}
}
$process = $this->configHelper->buildProcess($url, $uniqueId, $arguments);
$exitCode = $process->run();
if ($exitCode != 0) {
throw new \Exception(sprintf("Rasterize script failed.\nCommandLine: %s\nExitCode: %d\nErrorOutput: %s", $process->getCommandLine(), $process->getExitCode(), $process->getErrorOutput()));
}
if ($this->stopwatch instanceof Stopwatch) {
$this->stopwatch->stop($uniqueId);
}
$output = $this->configHelper->getOutputFilePath($uniqueId);
$content = file_get_contents($output);
unlink($output);
return $content;
}
function it_stops(Stopwatch $stopwatch, StopwatchEvent $event)
{
$stopwatch->getEvent('dom_manipulator_rules')->shouldBeCalled()->willReturn($event);
$stopwatch->stop('dom_manipulator')->shouldBeCalled()->willReturn($event);
$stopwatch->stop('dom_manipulator_manipulation')->shouldBeCalled()->willReturn($event);
$this->stop();
}
/**
* Logs with an arbitrary level.
*
* @param mixed $level
* @param string $message
* @param array $context
* @return null
*/
public function log($level, $message, array $context = array())
{
if (null === $this->logger) {
return;
}
$add = true;
$stackTrace = $this->getStackTrace();
if (null !== $this->stopwatch) {
$trace = debug_backtrace();
$method = $trace[3]['function'];
$watch = 'Propel Query ' . (count($this->queries) + 1);
if ('prepare' === $method) {
$this->isPrepared = true;
$this->stopwatch->start($watch, 'propel');
$add = false;
} elseif ($this->isPrepared) {
$this->isPrepared = false;
$event = $this->stopwatch->stop($watch);
}
}
// $trace[2] has no 'object' key if an exception is thrown while executing a query
if ($add && isset($event) && isset($trace[2]['object'])) {
$connection = $trace[2]['object'];
$this->queries[] = array('sql' => $message, 'connection' => $connection->getName(), 'time' => $event->getDuration() / 1000, 'memory' => $event->getMemory(), 'stackTrace' => $stackTrace);
}
$this->logger->log($level, $message, $context);
}
/**
* @return string
*/
public function compile()
{
$this->stopwatch->start('webpack.total');
$this->stopwatch->start('webpack.prepare');
// Recompile twig templates where its needed.
$this->addSplitPoints();
$this->addResolveConfig();
// Write the webpack configuration file.
file_put_contents($this->cache_dir . DIRECTORY_SEPARATOR . 'webpack.config.js', $this->generator->getConfiguration());
$this->profiler->set('compiler.performance.prepare', $this->stopwatch->stop('webpack.prepare')->getDuration());
$this->stopwatch->start('webpack.compiler');
$this->process->run();
$output = $this->process->getOutput() . $this->process->getErrorOutput();
$this->profiler->set('compiler.executed', true);
$this->profiler->set('compiler.successful', strpos($output, 'Error:') === false);
$this->profiler->set('compiler.last_output', $output);
if ($this->profiler->get('compiler.successful')) {
$this->tracker->rebuild();
}
// Finally, write some logging for later use.
file_put_contents($this->cache_dir . DIRECTORY_SEPARATOR . 'webpack.compiler.log', $output);
$this->profiler->set('compiler.performance.compiler', $this->stopwatch->stop('webpack.compiler')->getDuration());
$this->profiler->set('compiler.performance.total', $this->stopwatch->stop('webpack.total')->getDuration());
return $output;
}
/**
* @param RequestInterface $request
* @param ResponseInterface $response
*
* @return array
*/
protected function getLogData(RequestInterface $request, ResponseInterface $response = null)
{
$time = $this->stopwatch->stop(self::STOPWATCH_EVENT)->getDuration();
$uagent = $request->getHeader('User-Agent', '-');
$uagent = $uagent[0];
$xcache = $response && $response->hasHeaderWithValue('x-cache', 'HIT') ? 'HIT' : 'MISS';
$postDumpLimit = 200;
$postData = json_encode($request->getPostParams());
if (strlen($postData) > $postDumpLimit) {
$postData = substr($postData, 0, $postDumpLimit) . '...';
}
$data = array();
$data[] = $xcache;
$data[] = bcdiv($time, 1000, 4);
// milliseconds
$data[] = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '127.0.0.1';
// @todo ip is always set to 127.0.0.1 due to broken request object
$data[] = $request->getMethod();
$data[] = $request->getUri();
$data[] = $response ? $response->getStatusCode() : '-';
// bytes
$data[] = $response ? $response->getLength() : '-';
// bytes
$data[] = sprintf('"%s"', $uagent);
$data[] = $postData;
return $data;
}
/** {@inheritdoc} */
public function invoke($calls)
{
$this->stopwatch->start($this->clientName, 'rpc_call');
$collection = new TraceableResponseCollection($this->client->invoke($calls), $this->stopwatch, $this->clientName);
$this->stopwatch->stop($this->clientName);
return $collection;
}
/** {@inheritdoc} */
public function getResponse(RpcRequestInterface $request)
{
$this->stopwatch->start($this->client, 'rpc_response');
$response = $this->collection->getResponse($request);
$this->stopwatch->stop($this->client);
return $response;
}
/**
* @inheritDoc
*/
public function fetchWithNamespace($id, $namespaceId = null)
{
self::$stopwatch->start('doctrine_cache_extension_bundle');
$data = $this->cacheProviderDecorator->fetchWithNamespace($id, $namespaceId);
self::$stopwatch->stop('doctrine_cache_extension_bundle');
self::$collectedData[self::$callId++] = new FetchWithNamespaceCacheCollectedData($id, $namespaceId, $data, self::$stopwatch);
return $data;
}
/**
* @return void
*/
public function stopQuery()
{
if ($this->stopwatch) {
$this->stopwatch->stop('sphinx');
}
$this->queries[$this->queryCurrent]['time'] = microtime(true) - $this->queryStart;
$this->queryCurrent++;
}
/**
* @param ConsoleTerminateEvent $event
*/
public function onConsoleTerminate(ConsoleTerminateEvent $event)
{
if ('check' == $event->getCommand()->getName()) {
$stopEvent = $this->stopwatch->stop('check_command');
$output = $event->getOutput();
$output->writeln(sprintf('Checked source files in %s seconds, %s MB memory used', $stopEvent->getDuration() / 1000, $stopEvent->getMemory() / 1024 / 1024));
}
}
/**
* @param string $function
* @param array $arguments
*
* @return mixed
*/
private function collectFilter($function, $arguments)
{
$this->stopwatch->start('acl.filters');
$result = call_user_func_array([$this->aclFilter, $function], $arguments);
$periods = $this->stopwatch->stop('acl.filters')->getPeriods();
$this->filters[] = ['method' => $function, 'query' => $result->getSQL(), 'time' => end($periods)->getDuration()];
return $result;
}
/**
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
$stopwatchEvent = $this->stopwatch->stop('request');
$duration = $stopwatchEvent->getDuration();
$attributes = $this->flattenAttributes($event->getRequest()->attributes->all());
$data = ['service' => 'request.duration', 'metrics' => $duration];
$this->logger->log($data, $attributes);
}
/**
* {@inheritdoc}
*/
public function trace(array $spans)
{
$key = count($spans) == 1 ? $spans[0]->getName() : count($spans);
$key = 'trace (' . $key . ')';
$this->stopwatch->start($key);
$this->decoratedTracer->trace($spans);
$this->stopwatch->stop($key);
}
/**
* @param string|array $data
* @param string $routeName
* @param array[] $routeParameters
*/
public function push($data, $routeName, array $routeParameters = array(), array $context = [])
{
$eventName = 'push.' . $this->getName();
$this->stopwatch->start($eventName, 'websocket');
$this->pusher->push($data, $routeName, $routeParameters, $context);
$this->stopwatch->stop($eventName);
$this->dataCollector->collectData($this->stopwatch->getEvent($eventName), $this->getName());
}
/**
* Stops the stopwatch.
*
* @param RequestInterface $request
* @param ResponseInterface $response
*/
private function onRequestComplete(RequestInterface $request, ResponseInterface $response)
{
$hash = $this->hash($request);
// Send the log message to the adapter, adding a category and host
$priority = $response && $this->isError($response) ? LOG_ERR : LOG_DEBUG;
$message = $this->formatter->format($request, $response);
$event = $this->stopwatch->stop($hash);
$this->logAdapter->log($message, $priority, array('request' => $request, 'response' => $response, 'time' => $event->getDuration()));
}
/**
* {@inheritdoc}
*/
public function end(LogOperation $log)
{
if (!is_null($this->stopwatch)) {
$this->stopwatch->stop('ldaptools');
}
if (!is_null($this->logger)) {
$this->log($log);
}
}
/**
* Stop and assign values to contao debug bar.
*
* @return void
*
* @SuppressWarnings(PHPMD.Superglobals)
*/
public function stop()
{
$rulesEvent = $this->watch->getEvent('dom_manipulator_rules');
$manipulationEvent = $this->watch->stop('dom_manipulator_manipulation');
$totalEvent = $this->watch->stop('dom_manipulator');
$GLOBALS['TL_DEBUG']['dom_manipulator_total'] = $this->formatDuration('total', $totalEvent);
$GLOBALS['TL_DEBUG']['dom_manipulator_rules'] = $this->formatDuration('rule creation', $rulesEvent);
$GLOBALS['TL_DEBUG']['dom_manipulator_dom'] = $this->formatDuration('manipulation', $manipulationEvent);
}
/**
* {@inheritdoc}
*/
public function sendRequest($body)
{
$stopwatchId = uniqid('speicher210_fastbill.collector.transport.');
$this->stopwatch->start($stopwatchId);
$return = $this->service->sendRequest($body);
$stop = $this->stopwatch->stop($stopwatchId);
$this->requests[] = array('time' => $stop->getDuration(), 'request' => json_decode($body, true), 'response' => json_decode($return, true));
return $return;
}
/**
* @internal
*
* @param string $name
* @param array $arguments
*
* @return mixed
*/
public function __call($name, array $arguments)
{
$this->stopwatch->start($this->name, $name);
$this->logger->debug('> ' . $this->name . '::' . $name, $arguments);
$r = call_user_func_array([$this->originalClient, $name], $arguments);
$this->logger->debug('< ' . $this->name . '::' . $name, [$r]);
$this->stopwatch->stop($this->name);
return $r;
}
/**
* Returns a callable handler that stops the stopwatch for the given request when it is successful.
* (Fills the X-Duration header with the duration of the request in milliseconds.)
*
* @param RequestInterface $request The request.
*
* @return \Closure Handler.
*/
protected function onSuccess(RequestInterface $request)
{
return function (ResponseInterface $response) use($request) {
if (null !== $this->stopwatch) {
$event = $this->stopwatch->stop((string) $request->getUri());
return $response->withHeader('X-Duration', $event->getDuration());
}
return $response;
};
}
/**
* @param int $fileCount
* @param int $violationCount
*/
public function endProgress($fileCount, $violationCount)
{
$stats = $this->stopwatch->stop(static::PROGRESS_NAME);
if (0 === $violationCount) {
$this->output->writeln('<info>There are no violations - congratulations!</info>');
} else {
$this->output->writeln(sprintf('<comment>%s deprecations found.</comment>', $violationCount));
}
$this->output->writeln(sprintf('Checked %s source files in %s seconds, %s MB memory used', $fileCount, $stats->getDuration() / 1000, $stats->getMemory() / 1024 / 1024));
}
/**
* Ends the watch, extract logs and write them to the storage service chosen.
* @param $identifier
* @param OutputInterface|null $output If you want to write on output the logs
* @param array $extra
*
* @return array
*/
public function end($identifier, OutputInterface $output = null, $extra = array())
{
$logs = array();
if ($this->stopWatch->isStarted($identifier)) {
$stopWatchEvent = $this->stopWatch->stop($identifier);
$logs = $this->extractLog($stopWatchEvent, $output, $extra);
$this->writer->write($logs, $identifier);
}
return $logs;
}
/**
* @param string|null $returnValue
*
* @return string
*/
public function stop($returnValue = null)
{
$this->output = ob_get_clean();
$this->returnValue = $returnValue;
$event = $this->stopWatch->stop($this->randomName);
$this->duration = $event->getDuration();
$this->memory = $event->getMemory();
$this->startAt = $event->getOrigin();
return $this->serialize();
}
/**
* {@inheritdoc}
*/
public function stopQuery()
{
parent::stopQuery();
if (null !== $this->stopwatch) {
$this->stopwatch->stop('doctrine');
}
if ($this->enabled) {
$this->queries[$this->currentQuery]['callstack'] = $this->callstack;
}
}
/**
* {@inheritdoc}
*/
protected function doSendInternalRequests(array $internalRequests)
{
$this->stopwatch->start($name = 'ivory.http_adapter');
try {
$result = parent::doSendInternalRequests($internalRequests);
} catch (\Exception $e) {
$this->stopwatch->stop($name);
throw $e;
}
$this->stopwatch->stop($name);
return $result;
}
/**
* {@inheritdoc}
*/
public function handleRequest(RequestInterface $request, callable $next, callable $first)
{
$eventName = $this->getStopwatchEventName($request);
$this->stopwatch->start($eventName, self::CATEGORY);
return $next($request)->then(function (ResponseInterface $response) use($eventName) {
$this->stopwatch->stop($eventName, self::CATEGORY);
return $response;
}, function (Exception $exception) use($eventName) {
$this->stopwatch->stop($eventName, self::CATEGORY);
throw $exception;
});
}
/**
* Registers this collector on the event dispatcher
*
* @param \Symfony\Component\EventDispatcher\EventDispatcher
* @return void
*/
public function register($eventDispatcher)
{
// Add the listeners to start and stop events
$eventDispatcher->addListener(WardenEvents::WARDEN_START, function (StartEvent $event) {
$this->stopwatch->start('request');
});
$eventDispatcher->addListener(WardenEvents::WARDEN_END, function (StopEvent $event) {
$sw = $this->stopwatch->stop('request');
$event->params->setValue('request_time', $sw->getDuration());
$event->params->setValue('request_memory', $sw->getMemory());
});
}
/**
* {@inheritdoc}
*/
protected function decorate($method, array $params = array())
{
$this->stopwatch->start($name = 'ivory.http_adapter');
try {
$result = parent::decorate($method, $params);
} catch (\Exception $e) {
$this->stopwatch->stop($name);
throw $e;
}
$this->stopwatch->stop($name);
return $result;
}
/**
* @param string $path
* @param string $method
* @param array $data
* @param array $query
*
* @return \Elastica\Response
*/
public function request($path, $method = Request::GET, $data = array(), array $query = array())
{
if ($this->stopwatch) {
$this->stopwatch->start('es_request', 'fos_elastica');
}
$start = microtime(true);
$response = parent::request($path, $method, $data, $query);
$this->logQuery($path, $method, $data, $query, $start);
if ($this->stopwatch) {
$this->stopwatch->stop('es_request');
}
return $response;
}
