/** * Forwards the request to the Frontend class if there is a page object. * * @param PostResponseEvent $event The event object */ public function onKernelTerminate(PostResponseEvent $event) { if (!$this->framework->isInitialized()) { return; } Frontend::indexPageIfApplicable($event->getResponse()); }
public function onKernelTerminate(PostResponseEvent $event) { if (!$event->isMasterRequest() || !$event->getRequest()->headers->has(self::GENERATE_LOG_HEADER)) { return; } $this->responseLogger->logReponse($event->getRequest(), $event->getResponse()); }
/** * @param PostResponseEvent $event */ public function onTerminate(PostResponseEvent $event) { if (!$event->isMasterRequest()) { return; } $this->eventDispatcher->dispatch(Events::REQUEST_ENDS, new RequestEnded($event->getRequest(), $event->getResponse())); }
public function onKernelTerminate(PostResponseEvent $event) { /** @var Request $request */ $request = $event->getRequest(); if (!$this->isEnable || !$this->isLoggableRequest($request)) { return; } try { /** @var Response $response */ $response = $event->getResponse(); $route = $request->get('_route'); $content = $this->cleanSensitiveContent($route, $request->getContent()); $token = $this->tokenStorage->getToken(); $user = !is_null($token) ? $token->getUser() : null; $logRequest = new LogRequest(); $logRequest->setRoute($route)->setPath($request->getPathInfo())->setMethod($request->getMethod())->setQuery(urldecode($request->getQueryString()))->setContent($content)->setStatus($response->getStatusCode())->setIp($request->getClientIp())->setUser(!is_string($user) ? $user : null); if ($this->logResponse($response)) { $logRequest->setResponse($response->getContent()); } $this->em->persist($logRequest); $this->em->flush(); } catch (\Exception $e) { $this->logger->error(sprintf("LogRequest couldn't be persist : %s", $e->getMessage())); } }
function it_do_not_trace_if_no_request_in_stack(Tracer $tracer, SpanStack $spanStack, Span $span, PostResponseEvent $event) { $event->isMasterRequest()->willReturn(true); $spanStack->pop()->willReturn(null); $tracer->trace(Argument::any())->shouldNotBeCalled(); $this->onKernelTerminate($event); }
/** * Save the previous URL in session which is based on the referer header or the request, or * the _previous_url request attribute, if defined. * * If the value of _previous_url is "dont-save", the current referrer is not saved. * * @param FilterResponseEvent $event */ public function registerPreviousUrl(PostResponseEvent $event) { $request = $event->getRequest(); $referrer = $request->attributes->get('_previous_url', null); if (null !== $referrer) { // A previous URL (or the keyword 'dont-save') has been specified. if ('dont-save' == $referrer) { // We should not save the current URL as the previous URL $referrer = null; } } else { // The current URL will become the previous URL $referrer = $request->getUri(); } // Set previous URL, if defined if (null !== $referrer) { $session = $request->getSession(); if (ConfigQuery::read("one_domain_foreach_lang", false) == 1) { $components = parse_url($referrer); $lang = LangQuery::create()->filterByUrl(sprintf("%s://%s", $components["scheme"], $components["host"]), ModelCriteria::LIKE)->findOne(); if (null !== $lang) { $session->setReturnToUrl($referrer); } } else { if (false !== strpos($referrer, $request->getSchemeAndHttpHost())) { $session->setReturnToUrl($referrer); } } } }
/** * @param PostResponseEvent $event * * @return float */ protected function getExecutionTime(PostResponseEvent $event) { $request = $event->getRequest(); $startTime = $request->server->get('REQUEST_TIME_FLOAT', $request->server->get('REQUEST_TIME')); $time = microtime(true) - $startTime; return round($time * 1000); }
public function onKernelTerminate(PostResponseEvent $event) { $requestMethod = $event->getRequest()->getMethod(); $requestUri = $event->getRequest()->getRequestUri(); if (strpos($requestUri, '/api/orders') && ($requestMethod == 'PUT' || $requestMethod == 'POST')) { $this->getOrderUpdater()->processIds(); } }
/** * dispatchRequestTime dispatch the request time. * This time is a "fake" one, because some actions are performed before the initialization of the request * It is ~100ms smaller than the real kernel time. * * @param PostResponseEvent $event */ private function dispatchRequestTime(PostResponseEvent $event) { $request = $event->getRequest(); $startTime = $request->server->get('REQUEST_TIME_FLOAT', $request->server->get('REQUEST_TIME')); $time = microtime(true) - $startTime; $time = round($time * 1000); $this->eventDispatcher->dispatch('statsd.time', new StatsdEvent($time)); }
/** * @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); }
/** * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { if (!$event->isMasterRequest()) { return; } if ($span = $this->spanStack->pop()) { $this->tracer->trace([$this->httpFoundationSpanFactory->fromOutgoingResponse($event->getResponse(), $span)]); } }
/** * Forwards the request to the Frontend class if there is a page object. * * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { if (!$this->framework->isInitialized()) { return; } /** @var Frontend $frontend */ $frontend = $this->framework->getAdapter('Contao\\Frontend'); $frontend->indexPageIfApplicable($event->getResponse()); }
/** * Run the automated cron if enabled. * * @param \Symfony\Component\HttpKernel\Event\PostResponseEvent $event * The Event to process. */ public function onTerminate(PostResponseEvent $event) { $interval = $this->config->get('interval'); if ($interval > 0) { $cron_next = $this->state->get('system.cron_last', 0) + $interval; if ((int) $event->getRequest()->server->get('REQUEST_TIME') > $cron_next) { $this->cron->run(); } } }
/** * @param PostResponseEvent $event */ public function onTerminate(PostResponseEvent $event) { $response = $event->getResponse(); if (!is_null($this->logger)) { $this->logger->info('< ' . $response->getStatusCode()); if (!is_null($this->benchmark)) { $total = $this->benchmark->getAppStatistic(); $this->logger->info('= Time: ' . $total['time'] . ', Memory: ' . FileSizeHelper::humanize($total['memory'])); } } }
/** * Updates the user last action * * @param PostResponseEvent $event */ public function onRequestTermination(PostResponseEvent $event) { $this->userFetcher->setThrowOnTokenError(false); if (null === ($user = $this->userFetcher->resolve())) { return; } $requestTime = $event->getRequest()->server->get('REQUEST_TIME'); $dateTime = new \DateTime(); $dateTime->setTimestamp($requestTime); $user->updateLastAction($dateTime); $this->userRepository->modify($user); }
/** * Forwards the request to the Frontend class if there is a page object. * * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { if (!$this->framework->isInitialized()) { return; } // Do not index fragments if (preg_match('~(?:^|/)' . preg_quote($this->fragmentPath, '~') . '/~', $event->getRequest()->getPathInfo())) { return; } /** @var Frontend $frontend */ $frontend = $this->framework->getAdapter(Frontend::class); $frontend->indexPageIfApplicable($event->getResponse()); }
/** * Apply invalidators and flush cache manager * * On kernel.terminate: * - see if any invalidators apply to the current request and, if so, add * their routes to the cache manager; * - flush the cache manager in order to send invalidation requests to the * HTTP cache. * * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { $request = $event->getRequest(); $response = $event->getResponse(); // Don't invalidate any caches if the request was unsuccessful if ($response->isSuccessful()) { $this->handleInvalidation($request, $response); } try { $this->cacheManager->flush(); } catch (ExceptionCollection $e) { // swallow exception // there is the fos_http_cache.event_listener.log to log them } }
public function onKernelTerminate(PostResponseEvent $pre) { //Symfony2 locks the session for the Request's lifecycle. //Here, we need this method to be executed asynchronously. //Thus, we release the session immediately. //$pre->getRequest()->getSession()->save(); $this->container->get('session')->save(); session_write_close(); if ($pre->getRequest()->attributes->has('fetch_request')) { $attr = $pre->getRequest()->attributes->get('fetch_request'); try { $this->fetcher->fetch($attr['resource'], $attr['url']); } catch (ResourceFetcherException $e) { $this->logger->error("AsyncFetchListener Error : " . $e->getMessage()); } } }
/** * If needed, executes the ezperformancelogger logging on the Symfony Post-Response event * We wrap the logging code in a runCallback call, as it might need to read inis and such stuff * NB: we do not need to check for request type - this event only fires on master requests * * @param $event */ public function onTerminate(PostResponseEvent $event) { // small speed gain: avoid useless callback if measurement was already done if ($this->hasRun) { return; } $response = $event->getResponse(); $legacyKernelClosure = $this->legacyKernelClosure; $legacyKernel = $legacyKernelClosure(); // accommodate for treemenu kernel not allowing runCallback try { $legacyKernel->runCallback(function () use($response) { eZPerfLogger::cleanup($response->getContent(), $response->getStatusCode()); }); } catch (\RuntimeException $e) { } $this->hasRun = true; }
/** * Runs the cron job after the response was sent * * @param PostResponseEvent $event The event */ public function on_kernel_terminate(PostResponseEvent $event) { $request = $event->getRequest(); $controller_name = $request->get('_route'); if ($controller_name !== 'phpbb_cron_run') { return; } $cron_type = $request->get('cron_type'); if ($this->cron_lock->acquire()) { $task = $this->cron_manager->find_task($cron_type); if ($task) { if ($task->is_parametrized()) { $task->parse_parameters($this->request); } if ($task->is_ready()) { $task->run(); } $this->cron_lock->release(); } } }
public function onKernelTerminate(PostResponseEvent $event) { if ($this->container->has('profiler')) { /** @var $profiler \Symfony\Component\HttpKernel\Profiler\Profiler */ $profiler = $this->container->get('profiler'); if ($profile = $profiler->loadProfileFromResponse($event->getResponse())) { $logRequest = $this->jarvesLogHandler->getLogRequest(); $logRequest->setCounts(json_encode($this->jarvesLogHandler->getCounts())); $logRequest->setProfileToken($profile->getToken()); $logRequest->save(); return; } } //are there any warnings+? if ($this->jarvesLogHandler->getCounts()) { $logRequest = $this->jarvesLogHandler->getLogRequest(); $logRequest->setCounts(json_encode($this->jarvesLogHandler->getCounts())); $logRequest->save(); } $this->jarvesLogHandler->resetLogRequest(); }
/** * @param PostResponseEvent $event */ public function onTerminate(PostResponseEvent $event) { if (!$event->isMasterRequest()) { return; } $request = $event->getRequest(); if ($request->getRealMethod() == 'OPTIONS') { return; } if (!preg_match($this->rule, $request->getRequestUri())) { return; } $response = $event->getResponse(); $message = $this->formatter->format($request, $response); if ($response->isClientError()) { $this->logger->error($message); return; } if ($response->isServerError()) { $this->logger->critical($message); return; } $this->logger->info($message); }
/** * @param PostResponseEvent $event */ public function cacheData(PostResponseEvent $event) { if ($event->getRequest()->query->get('no-cache', null)) { return; } if (array_key_exists($route = $event->getRequest()->attributes->get('_route'), $this->cachedRoutes)) { /** @var Response $response */ $response = $event->getResponse(); if ($response->getStatusCode() < 400) { if (!$event->getRequest()->attributes->has('cached_data')) { $this->responseCacher->writeCache($event->getRequest(), $event->getResponse(), $this->cachedRoutes[$route]); } } } }
/** * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { $request = new Request($event->getRequest(), $event->getResponse(), $this->getUsername()); $this->entityManager->persist($request); $this->entityManager->flush(); }
/** * Save new messages * * @author Krzysztof Bednarczyk */ public function onKernelTerminate(PostResponseEvent $event) { if (!$event->isMasterRequest()) { return; } if (!method_exists($this->translator, 'getCollectedMessages')) { return; } $messages = $this->translator->getCollectedMessages(); if (empty($messages)) { return; } $languagesToClear = []; foreach ($messages as $message) { if (!in_array((int) $message['state'], [DataCollectorTranslator::MESSAGE_MISSING, DataCollectorTranslator::MESSAGE_EQUALS_FALLBACK])) { continue; } if (!$this->manager->hasLocale($message['locale'])) { continue; } $language = $this->manager->getLanguage($message['locale']); $languagesToClear[$language->getId()] = $language; $this->manager->createTranslation($language, $message['id'], $message['domain']); } foreach ($languagesToClear as $language) { $this->manager->clearTranslationCache($language); } }
/** * @param PostResponseEvent $event */ public function onKernelTerminate(PostResponseEvent $event) { $route = $this->getRoute($event->getRequest()); $this->logger->info('PROCESS END', array($route)); }
public function onKernelTerminate(PostResponseEvent $event) { $this->releaseLocks($event->getRequest()); }
/** * Listen to requests on the pages corresponding to analysis reading actions and mark the associated * analyses as viewed by setting their "new" property to false. * * @param PostResponseEvent $event * * @return void */ public function onTerminate(PostResponseEvent $event) { $requestAttributes = $event->getRequest()->attributes; // Firstly, we check if we are on an analysis reading page and afterwards, we try to fetch // the analysis id from the request attributes. if (!in_array($requestAttributes->get('_route'), $this->analysisViewingRoutes) || ($analysisId = $requestAttributes->get('id')) === null) { return; } // Try to fetch the analysis from the database. $analysis = $this->doctrine->getRepository('PHPSanitizer\\ProjectBundle\\Entity\\Analysis')->find($analysisId); // Check if the analysis actually exists and if the user was allowed to read its results. if ($analysis !== null && $this->authorizationChecker->isGranted('VIEW', $analysis->getProject())) { // Finally, mark the analysis as viewed. $this->markViewedAnalysis($analysis); } }
public function __construct(Request $request, Response $response) { parent::__construct(new NullHttpKernel(), $request, $response); }
/** * On kernel terminate * * @param PostResponseEvent $postResponseEvent postResponseEvent * * @return void */ public function onKernelTerminate(PostResponseEvent $postResponseEvent) { $request = $postResponseEvent->getRequest(); $transaction = $request->attributes->get('transaction'); if ($transaction) { $this->entityManager->clear(); $this->entityManager->persist($transaction); $this->entityManager->flush(); } }