\d+))?#';
40 | if (preg_match($clockworkDataUri, $request->getUri()->getPath(), $matches)) {
41 | $matches = array_merge([ 'id' => null, 'direction' => null, 'count' => null ], $matches);
42 | return $this->retrieveRequest($request, $matches['id'], $matches['direction'], $matches['count']);
43 | }
44 |
45 | $response = $handler->handle($request);
46 |
47 | return $this->logRequest($request, $response);
48 | }
49 |
50 | protected function authenticate(Request $request)
51 | {
52 | $token = $this->clockwork->authenticator()->attempt($request->getParsedBody());
53 |
54 | return $this->jsonResponse([ 'token' => $token ], $token ? 200 : 403);
55 | }
56 |
57 | protected function retrieveRequest(Request $request, $id, $direction, $count)
58 | {
59 | $authenticator = $this->clockwork->authenticator();
60 | $storage = $this->clockwork->storage();
61 |
62 | $authenticated = $authenticator->check(current($request->getHeader('X-Clockwork-Auth')));
63 |
64 | if ($authenticated !== true) {
65 | return $this->jsonResponse([ 'message' => $authenticated, 'requires' => $authenticator->requires() ], 403);
66 | }
67 |
68 | if ($direction == 'previous') {
69 | $data = $storage->previous($id, $count);
70 | } elseif ($direction == 'next') {
71 | $data = $storage->next($id, $count);
72 | } elseif ($id == 'latest') {
73 | $data = $storage->latest();
74 | } else {
75 | $data = $storage->find($id);
76 | }
77 |
78 | return $this->jsonResponse($data);
79 | }
80 |
81 | protected function logRequest(Request $request, $response)
82 | {
83 | $this->clockwork->timeline()->finalize($this->startTime);
84 | $this->clockwork->addDataSource(new PsrMessageDataSource($request, $response));
85 |
86 | $this->clockwork->resolveRequest();
87 | $this->clockwork->storeRequest();
88 |
89 | $clockworkRequest = $this->clockwork->request();
90 |
91 | $response = $response
92 | ->withHeader('X-Clockwork-Id', $clockworkRequest->id)
93 | ->withHeader('X-Clockwork-Version', Clockwork::VERSION);
94 |
95 | if ($basePath = $this->app->getBasePath()) {
96 | $response = $response->withHeader('X-Clockwork-Path', "$basePath/__clockwork/");
97 | }
98 |
99 | return $response->withHeader('Server-Timing', ServerTiming::fromRequest($clockworkRequest)->value());
100 | }
101 |
102 | protected function createDefaultClockwork($storagePath)
103 | {
104 | $clockwork = new Clockwork();
105 |
106 | $clockwork->storage(new FileStorage($storagePath));
107 | $clockwork->authenticator(new NullAuthenticator);
108 |
109 | return $clockwork;
110 | }
111 |
112 | protected function jsonResponse($data, $status = 200)
113 | {
114 | $response = $this->app->getResponseFactory()
115 | ->createResponse($status)
116 | ->withHeader('Content-Type', 'application/json');
117 |
118 | $response->getBody()->write(json_encode($data));
119 |
120 | return $response;
121 | }
122 | }
123 |
--------------------------------------------------------------------------------
/Clockwork/Helpers/StackFilter.php:
--------------------------------------------------------------------------------
1 | classes = array_merge($this->classes, is_array($classes) ? $classes : [ $classes ]);
29 | return $this;
30 | }
31 |
32 | public function isNotClass($classes)
33 | {
34 | $this->notClasses = array_merge($this->notClasses, is_array($classes) ? $classes : [ $classes ]);
35 | return $this;
36 | }
37 |
38 | public function isFile($files)
39 | {
40 | $this->files = array_merge($this->files, is_array($files) ? $files : [ $files ]);
41 | return $this;
42 | }
43 |
44 | public function isNotFile($files)
45 | {
46 | $this->notFiles = array_merge($this->notFiles, is_array($files) ? $files : [ $files ]);
47 | return $this;
48 | }
49 |
50 | public function isFunction($functions)
51 | {
52 | $this->functions = array_merge($this->functions, is_array($functions) ? $functions : [ $functions ]);
53 | return $this;
54 | }
55 |
56 | public function isNotFunction($functions)
57 | {
58 | $this->notFunctions = array_merge($this->notFunctions, is_array($functions) ? $functions : [ $functions ]);
59 | return $this;
60 | }
61 |
62 | public function isNamespace($namespaces)
63 | {
64 | $this->namespaces = array_merge($this->namespaces, is_array($namespaces) ? $namespaces : [ $namespaces ]);
65 | return $this;
66 | }
67 |
68 | public function isNotNamespace($namespaces)
69 | {
70 | $this->notNamespaces = array_merge($this->notNamespaces, is_array($namespaces) ? $namespaces : [ $namespaces ]);
71 | return $this;
72 | }
73 |
74 | public function isVendor($vendors)
75 | {
76 | $this->vendors = array_merge($this->vendors, is_array($vendors) ? $vendors : [ $vendors ]);
77 | return $this;
78 | }
79 |
80 | public function isNotVendor($vendors)
81 | {
82 | $this->notVendors = array_merge($this->notVendors, is_array($vendors) ? $vendors : [ $vendors ]);
83 | return $this;
84 | }
85 |
86 | // Apply the filter to a stack frame
87 | public function filter(StackFrame $frame)
88 | {
89 | return $this->matchesClass($frame)
90 | && $this->matchesFile($frame)
91 | && $this->matchesFunction($frame)
92 | && $this->matchesNamespace($frame)
93 | && $this->matchesVendor($frame);
94 | }
95 |
96 | // Return a closure calling this filter
97 | public function closure()
98 | {
99 | return function ($frame) { return $this->filter($frame); };
100 | }
101 |
102 | protected function matchesClass(StackFrame $frame)
103 | {
104 | if (count($this->classes) && ! in_array($frame->class, $this->classes)) return false;
105 | if (count($this->notClasses) && in_array($frame->class, $this->notClasses)) return false;
106 |
107 | return true;
108 | }
109 |
110 | protected function matchesFile(StackFrame $frame)
111 | {
112 | if (count($this->files) && ! in_array($frame->file, $this->files)) return false;
113 | if (count($this->notFiles) && in_array($frame->file, $this->notFiles)) return false;
114 |
115 | return true;
116 | }
117 |
118 | protected function matchesFunction(StackFrame $frame)
119 | {
120 | if (count($this->functions) && ! in_array($frame->function, $this->functions)) return false;
121 | if (count($this->notFunctions) && in_array($frame->function, $this->notFunctions)) return false;
122 |
123 | return true;
124 | }
125 |
126 | protected function matchesNamespace(StackFrame $frame)
127 | {
128 | foreach ($this->notNamespaces as $namespace) {
129 | if ($frame->class !== null && strpos($frame->class, "{$namespace}\\") !== false) return false;
130 | }
131 |
132 | if (! count($this->namespaces)) return true;
133 |
134 | foreach ($this->namespaces as $namespace) {
135 | if ($frame->class !== null && strpos($frame->class, "{$namespace}\\") !== false) return true;
136 | }
137 |
138 | return false;
139 | }
140 |
141 | protected function matchesVendor(StackFrame $frame)
142 | {
143 | if (count($this->vendors) && ! in_array($frame->vendor, $this->vendors)) return false;
144 | if (count($this->notVendors) && in_array($frame->vendor, $this->notVendors)) return false;
145 |
146 | return true;
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/LaravelEventsDataSource.php:
--------------------------------------------------------------------------------
1 | dispatcher = $dispatcher;
25 |
26 | $this->ignoredEvents = is_array($ignoredEvents)
27 | ? array_merge($ignoredEvents, $this->defaultIgnoredEvents()) : [];
28 | }
29 |
30 | // Adds fired events to the request
31 | public function resolve(Request $request)
32 | {
33 | $request->events = array_merge($request->events, $this->events);
34 |
35 | return $request;
36 | }
37 |
38 | // Reset the data source to an empty state, clearing any collected data
39 | public function reset()
40 | {
41 | $this->events = [];
42 | }
43 |
44 | // Start listening to the events
45 | public function listenToEvents()
46 | {
47 | $this->dispatcher->listen('*', function ($event = null, $data = null) {
48 | if (method_exists($this->dispatcher, 'firing')) { // Laravel 5.0 - 5.3
49 | $data = func_get_args();
50 | $event = $this->dispatcher->firing();
51 | }
52 |
53 | $this->registerEvent($event, $data);
54 | });
55 | }
56 |
57 | // Collect a fired event, prepares data for serialization and resolves registered listeners
58 | protected function registerEvent($event, array $data)
59 | {
60 | if (! $this->shouldCollect($event)) return;
61 |
62 | $trace = StackTrace::get()->resolveViewName();
63 |
64 | $event = [
65 | 'event' => $event,
66 | 'data' => (new Serializer)->normalize(count($data) == 1 && isset($data[0]) ? $data[0] : $data),
67 | 'time' => microtime(true),
68 | 'listeners' => $this->findListenersFor($event),
69 | 'trace' => (new Serializer)->trace($trace)
70 | ];
71 |
72 | if ($this->passesFilters([ $event ])) {
73 | $this->events[] = $event;
74 | }
75 | }
76 |
77 | // Returns registered listeners for the specified event
78 | protected function findListenersFor($event)
79 | {
80 | $listener = $this->dispatcher->getListeners($event)[0];
81 |
82 | return array_filter(array_map(function ($listener) {
83 | if ($listener instanceof \Closure) {
84 | // Laravel 5.4+ (and earlier versions in some cases) wrap the listener into a closure,
85 | // attempt to resolve the original listener
86 | $use = (new \ReflectionFunction($listener))->getStaticVariables();
87 | $listener = isset($use['listener']) ? $use['listener'] : $listener;
88 | }
89 |
90 | if (is_string($listener)) {
91 | return $listener;
92 | } elseif (is_array($listener) && count($listener) == 2) {
93 | if (is_object($listener[0])) {
94 | return get_class($listener[0]) . '@' . $listener[1];
95 | } else {
96 | return $listener[0] . '::' . $listener[1];
97 | }
98 | } elseif ($listener instanceof \Closure) {
99 | $listener = new \ReflectionFunction($listener);
100 |
101 | if (strpos($listener->getNamespaceName(), 'Clockwork\\') === 0) { // skip our own listeners
102 | return;
103 | }
104 |
105 | $filename = str_replace(base_path(), '', $listener->getFileName());
106 | $startLine = $listener->getStartLine();
107 | $endLine = $listener->getEndLine();
108 |
109 | return "Closure ({$filename}:{$startLine}-{$endLine})";
110 | }
111 | }, $this->dispatcher->getListeners($event)));
112 | }
113 |
114 | // Returns whether the event should be collected (depending on ignored events)
115 | protected function shouldCollect($event)
116 | {
117 | return ! preg_match('/^(?:' . implode('|', $this->ignoredEvents) . ')$/', $event);
118 | }
119 |
120 | // Returns default ignored events (framework-specific events)
121 | protected function defaultIgnoredEvents()
122 | {
123 | return [
124 | 'Illuminate\\\\.+',
125 | 'Laravel\\\\.+',
126 | 'auth\.(?:attempt|login|logout)',
127 | 'artisan\.start',
128 | 'bootstrapped:.+',
129 | 'composing:.+',
130 | 'creating:.+',
131 | 'illuminate\.query',
132 | 'connection\..+',
133 | 'eloquent\..+',
134 | 'kernel\.handled',
135 | 'illuminate\.log',
136 | 'mailer\.sending',
137 | 'router\.(?:before|after|matched)',
138 | 'router.filter:.+',
139 | 'locale\.changed',
140 | 'clockwork\..+'
141 | ];
142 | }
143 | }
144 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/LaravelCacheDataSource.php:
--------------------------------------------------------------------------------
1 | 0, 'hit' => 0, 'write' => 0, 'delete' => 0
21 | ];
22 |
23 | // Whether we are collecting cache queries or stats only
24 | protected $collectQueries = true;
25 |
26 | // Whether we are collecting values from cache queries
27 | protected $collectValues = true;
28 |
29 | // Create a new data source instance, takes an event dispatcher and additional options as argument
30 | public function __construct(EventDispatcher $eventDispatcher, $collectQueries = true, $collectValues = true)
31 | {
32 | $this->eventDispatcher = $eventDispatcher;
33 |
34 | $this->collectQueries = $collectQueries;
35 | $this->collectValues = $collectValues;
36 | }
37 |
38 | // Adds cache queries and stats to the request
39 | public function resolve(Request $request)
40 | {
41 | $request->cacheQueries = array_merge($request->cacheQueries, $this->queries);
42 |
43 | $request->cacheReads += $this->count['read'];
44 | $request->cacheHits += $this->count['hit'];
45 | $request->cacheWrites += $this->count['write'];
46 | $request->cacheDeletes += $this->count['delete'];
47 |
48 | return $request;
49 | }
50 |
51 | // Reset the data source to an empty state, clearing any collected data
52 | public function reset()
53 | {
54 | $this->queries = [];
55 |
56 | $this->count = [
57 | 'read' => 0, 'hit' => 0, 'write' => 0, 'delete' => 0
58 | ];
59 | }
60 |
61 | // Start listening to cache events
62 | public function listenToEvents()
63 | {
64 | if (class_exists(\Illuminate\Cache\Events\CacheHit::class)) {
65 | $this->eventDispatcher->listen(\Illuminate\Cache\Events\CacheHit::class, function ($event) {
66 | $this->registerQuery([ 'type' => 'hit', 'key' => $event->key, 'value' => $event->value ]);
67 | });
68 | $this->eventDispatcher->listen(\Illuminate\Cache\Events\CacheMissed::class, function ($event) {
69 | $this->registerQuery([ 'type' => 'miss', 'key' => $event->key ]);
70 | });
71 | $this->eventDispatcher->listen(\Illuminate\Cache\Events\KeyWritten::class, function ($event) {
72 | $this->registerQuery([
73 | 'type' => 'write', 'key' => $event->key, 'value' => $event->value,
74 | 'expiration' => property_exists($event, 'seconds') ? $event->seconds : $event->minutes * 60
75 | ]);
76 | });
77 | $this->eventDispatcher->listen(\Illuminate\Cache\Events\KeyForgotten::class, function ($event) {
78 | $this->registerQuery([ 'type' => 'delete', 'key' => $event->key ]);
79 | });
80 | } else {
81 | // legacy Laravel 5.1 style events
82 | $this->eventDispatcher->listen('cache.hit', function ($key, $value) {
83 | $this->registerQuery([ 'type' => 'hit', 'key' => $key, 'value' => $value ]);
84 | });
85 | $this->eventDispatcher->listen('cache.missed', function ($key) {
86 | $this->registerQuery([ 'type' => 'miss', 'key' => $key ]);
87 | });
88 | $this->eventDispatcher->listen('cache.write', function ($key, $value, $minutes) {
89 | $this->registerQuery([
90 | 'type' => 'write', 'key' => $key, 'value' => $value, 'expiration' => $minutes * 60
91 | ]);
92 | });
93 | $this->eventDispatcher->listen('cache.delete', function ($key) {
94 | $this->registerQuery([ 'type' => 'delete', 'key' => $key ]);
95 | });
96 | }
97 | }
98 |
99 | // Collect an executed query
100 | protected function registerQuery(array $query)
101 | {
102 | $trace = StackTrace::get()->resolveViewName();
103 |
104 | $record = [
105 | 'type' => $query['type'],
106 | 'key' => $query['key'],
107 | 'expiration' => isset($query['expiration']) ? $query['expiration'] : null,
108 | 'time' => microtime(true),
109 | 'connection' => null,
110 | 'trace' => (new Serializer)->trace($trace)
111 | ];
112 |
113 | if ($this->collectValues && isset($query['value'])) {
114 | $record['value'] = (new Serializer)->normalize($query['value']);
115 | }
116 |
117 | $this->incrementQueryCount($record);
118 |
119 | if ($this->collectQueries && $this->passesFilters([ $record ])) {
120 | $this->queries[] = $record;
121 | }
122 | }
123 |
124 | // Increment query counts for collected query
125 | protected function incrementQueryCount($query)
126 | {
127 | if ($query['type'] == 'write') {
128 | $this->count['write']++;
129 | } elseif ($query['type'] == 'delete') {
130 | $this->count['delete']++;
131 | } else {
132 | $this->count['read']++;
133 |
134 | if ($query['type'] == 'hit') {
135 | $this->count['hit']++;
136 | }
137 | }
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/PhpDataSource.php:
--------------------------------------------------------------------------------
1 | time = PHP_SAPI !== 'cli' ? $this->getRequestTime() : $request->time;
14 | $request->method = $this->getRequestMethod();
15 | $request->url = $this->getRequestUrl();
16 | $request->uri = $this->getRequestUri();
17 | $request->headers = $this->getRequestHeaders();
18 | $request->getData = $this->getGetData();
19 | $request->postData = $this->getPostData();
20 | $request->requestData = $this->getRequestData();
21 | $request->sessionData = $this->getSessionData();
22 | $request->cookies = $this->getCookies();
23 | $request->responseStatus = $this->getResponseStatus();
24 | $request->responseTime = $this->getResponseTime();
25 | $request->memoryUsage = $this->getMemoryUsage();
26 |
27 | return $request;
28 | }
29 |
30 | // Get the request cookies (normalized with passwords removed)
31 | protected function getCookies()
32 | {
33 | return $this->removePasswords((new Serializer)->normalizeEach($_COOKIE));
34 | }
35 |
36 | // Get the request GET data (normalized with passwords removed)
37 | protected function getGetData()
38 | {
39 | return $this->removePasswords((new Serializer)->normalizeEach($_GET));
40 | }
41 |
42 | // Get the request POST data (normalized with passwords removed)
43 | protected function getPostData()
44 | {
45 | return $this->removePasswords((new Serializer)->normalizeEach($_POST));
46 | }
47 |
48 | // Get the request body data (attempt to parse as json, normalized with passwords removed)
49 | protected function getRequestData()
50 | {
51 | // The data will already be parsed into POST data by PHP in case of application/x-www-form-urlencoded requests
52 | if (count($_POST)) return;
53 |
54 | $requestData = file_get_contents('php://input');
55 | $requestJsonData = json_decode($requestData, true);
56 |
57 | return is_array($requestJsonData)
58 | ? $this->removePasswords((new Serializer)->normalizeEach($requestJsonData))
59 | : $requestData;
60 | }
61 |
62 | // Get the request headers
63 | protected function getRequestHeaders()
64 | {
65 | $headers = [];
66 |
67 | foreach ($_SERVER as $key => $value) {
68 | if (substr($key, 0, 5) !== 'HTTP_') continue;
69 |
70 | $header = substr($key, 5);
71 | $header = str_replace('_', ' ', $header);
72 | $header = ucwords(strtolower($header));
73 | $header = str_replace(' ', '-', $header);
74 |
75 | if (! isset($headers[$header])) {
76 | $headers[$header] = [ $value ];
77 | } else {
78 | $headers[$header][] = $value;
79 | }
80 | }
81 |
82 | ksort($headers);
83 |
84 | return $headers;
85 | }
86 |
87 | // Get the request method
88 | protected function getRequestMethod()
89 | {
90 | if (isset($_SERVER['REQUEST_METHOD'])) {
91 | return $_SERVER['REQUEST_METHOD'];
92 | }
93 | }
94 |
95 | // Get the response time
96 | protected function getRequestTime()
97 | {
98 | if (isset($_SERVER['REQUEST_TIME_FLOAT'])) {
99 | return $_SERVER['REQUEST_TIME_FLOAT'];
100 | }
101 | }
102 |
103 | // Get the request URL
104 | protected function getRequestUrl()
105 | {
106 | $https = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on';
107 | $host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : null;
108 | $addr = isset($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : null;
109 | $port = isset($_SERVER['SERVER_PORT']) ? $_SERVER['SERVER_PORT'] : null;
110 | $uri = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : null;
111 |
112 | $scheme = $https ? 'https' : 'http';
113 | $host = $host ?: $addr;
114 | $port = (! $https && $port != 80 || $https && $port != 443) ? ":{$port}" : '';
115 |
116 | // remove port number from the host
117 | $host = $host ? preg_replace('/:\d+$/', '', trim($host)) : null;
118 |
119 | return "{$scheme}://{$host}{$port}{$uri}";
120 | }
121 |
122 | // Get the request URI
123 | protected function getRequestUri()
124 | {
125 | if (isset($_SERVER['REQUEST_URI'])) {
126 | return $_SERVER['REQUEST_URI'];
127 | }
128 | }
129 |
130 | // Get the response status code
131 | protected function getResponseStatus()
132 | {
133 | return http_response_code();
134 | }
135 |
136 | // Get the response time (current time, assuming most of the application code has already run at this point)
137 | protected function getResponseTime()
138 | {
139 | return microtime(true);
140 | }
141 |
142 | // Get the session data (normalized with passwords removed)
143 | protected function getSessionData()
144 | {
145 | if (! isset($_SESSION)) return [];
146 |
147 | return $this->removePasswords((new Serializer)->normalizeEach($_SESSION));
148 | }
149 |
150 | // Get the peak memory usage in bytes
151 | protected function getMemoryUsage()
152 | {
153 | return memory_get_peak_usage(true);
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/Clockwork/Helpers/Serializer.php:
--------------------------------------------------------------------------------
1 | [
15 | \Illuminate\Container\Container::class,
16 | \Illuminate\Foundation\Application::class,
17 | \Laravel\Lumen\Application::class
18 | ],
19 | 'limit' => 10,
20 | 'toArray' => false,
21 | 'toString' => false,
22 | 'debugInfo' => true,
23 | 'jsonSerialize' => false,
24 | 'traces' => true,
25 | 'tracesFilter' => null,
26 | 'tracesSkip' => null,
27 | 'tracesLimit' => null
28 | ];
29 |
30 | // Create a new instance optionally with options overriding defaults
31 | public function __construct(array $options = [])
32 | {
33 | $this->options = $options + static::$defaults;
34 | }
35 |
36 | // Set default options for all new instances
37 | public static function defaults(array $defaults)
38 | {
39 | static::$defaults = $defaults + static::$defaults;
40 | }
41 |
42 | // Prepares the passed data to be ready for serialization, takes any kind of data to normalize as the first
43 | // argument, other arguments are used internally in recursion
44 | public function normalize($data, $context = null, $limit = null)
45 | {
46 | if ($context === null) $context = [ 'references' => [] ];
47 | if ($limit === null) $limit = $this->options['limit'];
48 |
49 | if (is_array($data)) {
50 | if ($limit === 0) return [ '__type__' => 'array', '__omitted__' => 'limit' ];
51 |
52 | return [ '__type__' => 'array' ] + $this->normalizeEach($data, $context, $limit - 1);
53 | } elseif (is_object($data)) {
54 | if ($data instanceof \Closure) return [ '__type__' => 'anonymous function' ];
55 |
56 | $className = get_class($data);
57 | $objectHash = spl_object_hash($data);
58 |
59 | if ($className === '__PHP_Incomplete_Class') return [ '__class__' => $className ];
60 |
61 | if ($limit === 0) return [ '__class__' => $className, '__omitted__' => 'limit' ];
62 |
63 | if (isset($context['references'][$objectHash])) return [ '__type__' => 'recursion' ];
64 |
65 | $context['references'][$objectHash] = true;
66 |
67 | if (isset($this->cache[$objectHash])) return $this->cache[$objectHash];
68 |
69 | if ($this->options['blackbox'] && in_array($className, $this->options['blackbox'])) {
70 | return $this->cache[$objectHash] = [ '__class__' => $className, '__omitted__' => 'blackbox' ];
71 | } elseif ($this->options['toString'] && method_exists($data, '__toString')) {
72 | return $this->cache[$objectHash] = (string) $data;
73 | }
74 |
75 | if ($this->options['debugInfo'] && method_exists($data, '__debugInfo')) {
76 | $data = (array) $data->__debugInfo();
77 | } elseif ($this->options['jsonSerialize'] && method_exists($data, 'jsonSerialize')) {
78 | $data = (array) $data->jsonSerialize();
79 | } elseif ($this->options['toArray'] && method_exists($data, 'toArray')) {
80 | $data = (array) $data->toArray();
81 | } else {
82 | $data = (array) $data;
83 | }
84 |
85 | $data = array_combine(
86 | array_map(function ($key) {
87 | // replace null-byte prefixes of protected and private properties used by php with * (protected)
88 | // and ~ (private)
89 | return preg_replace('/^\0.+?\0/', '~', str_replace("\0*\0", '*', $key));
90 | }, array_keys($data)),
91 | $this->normalizeEach($data, $context, $limit - 1)
92 | );
93 |
94 | return $this->cache[$objectHash] = [ '__class__' => $className ] + $data;
95 | } elseif (is_resource($data)) {
96 | return [ '__type__' => 'resource' ];
97 | }
98 |
99 | return $data;
100 | }
101 |
102 | // Normalize each member of an array (doesn't add metadata for top level)
103 | public function normalizeEach($data, $context = null, $limit = null) {
104 | return array_map(function ($item) use ($context, $limit) {
105 | return $this->normalize($item, $context, $limit);
106 | }, $data);
107 | }
108 |
109 | // Normalize a stack trace instance
110 | public function trace(StackTrace $trace)
111 | {
112 | if (! $this->options['traces']) return null;
113 |
114 | if ($this->options['tracesFilter']) $trace = $trace->filter($this->options['tracesFilter']);
115 | if ($this->options['tracesSkip']) $trace = $trace->skip($this->options['tracesSkip']);
116 | if ($this->options['tracesLimit']) $trace = $trace->limit($this->options['tracesLimit']);
117 |
118 | return array_map(function ($frame) {
119 | return [
120 | 'call' => $frame->call,
121 | 'file' => $frame->file,
122 | 'line' => $frame->line,
123 | 'isVendor' => (bool) $frame->vendor
124 | ];
125 | }, $trace->frames());
126 | }
127 |
128 | // Normalize an exception instance
129 | public function exception(/* Throwable */ $exception)
130 | {
131 | return [
132 | 'type' => get_class($exception),
133 | 'message' => $exception->getMessage(),
134 | 'code' => $exception->getCode(),
135 | 'file' => $exception->getFile(),
136 | 'line' => $exception->getLine(),
137 | 'trace' => (new Serializer([ 'tracesLimit' => false ]))->trace(StackTrace::from($exception->getTrace())),
138 | 'previous' => $exception->getPrevious() ? $this->exception($exception->getPrevious()) : null
139 | ];
140 | }
141 | }
142 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/LaravelHttpClientDataSource.php:
--------------------------------------------------------------------------------
1 | dispatcher = $dispatcher;
32 |
33 | $this->collectContent = $collectContent;
34 | $this->collectRawContent = $collectRawContent;
35 | }
36 |
37 | // Add sent notifications to the request
38 | public function resolve(Request $request)
39 | {
40 | $request->httpRequests = array_merge($request->httpRequests, $this->requests);
41 |
42 | return $request;
43 | }
44 |
45 | // Reset the data source to an empty state, clearing any collected data
46 | public function reset()
47 | {
48 | $this->requests = [];
49 | $this->executingRequests = [];
50 | }
51 |
52 | // Listen to the email and notification events
53 | public function listenToEvents()
54 | {
55 | $this->dispatcher->listen(ConnectionFailed::class, function ($event) { $this->connectionFailed($event); });
56 | $this->dispatcher->listen(RequestSending::class, function ($event) { $this->sendingRequest($event); });
57 | $this->dispatcher->listen(ResponseReceived::class, function ($event) { $this->responseReceived($event); });
58 | }
59 |
60 | // Collect an executing request
61 | protected function sendingRequest(RequestSending $event)
62 | {
63 | $trace = StackTrace::get()->resolveViewName();
64 |
65 | $request = (object) [
66 | 'request' => (object) [
67 | 'method' => $event->request->method(),
68 | 'url' => $this->removeAuthFromUrl($event->request->url()),
69 | 'headers' => $event->request->headers(),
70 | 'content' => $this->collectContent ? $event->request->data() : null,
71 | 'body' => $this->collectRawContent ? $event->request->body() : null
72 | ],
73 | 'response' => null,
74 | 'stats' => null,
75 | 'error' => null,
76 | 'time' => microtime(true),
77 | 'trace' => (new Serializer)->trace($trace)
78 | ];
79 |
80 | if ($this->passesFilters([ $request ])) {
81 | $this->requests[] = $this->executingRequests[spl_object_hash($event->request)] = $request;
82 | }
83 | }
84 |
85 | // Update last request with response details and time taken
86 | protected function responseReceived($event)
87 | {
88 | if (! isset($this->executingRequests[spl_object_hash($event->request)])) return;
89 |
90 | $request = $this->executingRequests[spl_object_hash($event->request)];
91 | $stats = $event->response->handlerStats();
92 |
93 | $request->duration = (microtime(true) - $request->time) * 1000;
94 | $request->response = (object) [
95 | 'status' => $event->response->status(),
96 | 'headers' => $event->response->headers(),
97 | 'content' => $this->collectContent ? $event->response->json() : null,
98 | 'body' => $this->collectRawContent ? $event->response->body() : null
99 | ];
100 | $request->stats = (object) [
101 | 'timing' => isset($stats['total_time_us']) ? (object) [
102 | 'lookup' => $stats['namelookup_time_us'] / 1000,
103 | 'connect' => ($stats['pretransfer_time_us'] - $stats['namelookup_time_us']) / 1000,
104 | 'waiting' => ($stats['starttransfer_time_us'] - $stats['pretransfer_time_us']) / 1000,
105 | 'transfer' => ($stats['total_time_us'] - $stats['starttransfer_time_us']) / 1000
106 | ] : null,
107 | 'size' => (object) [
108 | 'upload' => isset($stats['size_upload']) ? $stats['size_upload'] : null,
109 | 'download' => isset($stats['size_download']) ? $stats['size_download'] : null
110 | ],
111 | 'speed' => (object) [
112 | 'upload' => isset($stats['speed_upload']) ? $stats['speed_upload'] : null,
113 | 'download' => isset($stats['speed_download']) ? $stats['speed_download'] : null
114 | ],
115 | 'hosts' => (object) [
116 | 'local' => isset($stats['local_ip']) ? [ 'ip' => $stats['local_ip'], 'port' => $stats['local_port'] ] : null,
117 | 'remote' => isset($stats['primary_ip']) ? [ 'ip' => $stats['primary_ip'], 'port' => $stats['primary_port'] ] : null
118 | ],
119 | 'version' => isset($stats['http_version']) ? $stats['http_version'] : null
120 | ];
121 |
122 | unset($this->executingRequests[spl_object_hash($event->request)]);
123 | }
124 |
125 | // Update last request with error when connection fails
126 | protected function connectionFailed($event)
127 | {
128 | if (! isset($this->executingRequests[spl_object_hash($event->request)])) return;
129 |
130 | $request = $this->executingRequests[spl_object_hash($event->request)];
131 |
132 | $request->duration = (microtime(true) - $request->time) * 1000;
133 | $request->error = 'connection-failed';
134 |
135 | unset($this->executingRequests[spl_object_hash($event->request)]);
136 | }
137 |
138 | // Removes username and password from the URL
139 | protected function removeAuthFromUrl($url)
140 | {
141 | return preg_replace('#^(.+?://)(.+?@)(.*)$#', '$1$3', $url);
142 | }
143 | }
144 |
--------------------------------------------------------------------------------
/Clockwork/Storage/Search.php:
--------------------------------------------------------------------------------
1 | $condition = isset($search[$condition]) ? $search[$condition] : [];
27 | }
28 |
29 | foreach ([ 'stopOnFirstMismatch' ] as $option) {
30 | $this->$option = isset($options[$option]) ? $options[$option] : $this->$option;
31 | }
32 |
33 | $this->method = array_map('strtolower', $this->method);
34 | }
35 |
36 | // Create a new instance from request input
37 | public static function fromRequest($data = [])
38 | {
39 | return new static($data);
40 | }
41 |
42 | // Check whether the request matches current search parameters
43 | public function matches(Request $request)
44 | {
45 | if ($request->type == RequestType::COMMAND) {
46 | return $this->matchesCommand($request);
47 | } elseif ($request->type == RequestType::QUEUE_JOB) {
48 | return $this->matchesQueueJob($request);
49 | } elseif ($request->type == RequestType::TEST) {
50 | return $this->matchesTest($request);
51 | } else {
52 | return $this->matchesRequest($request);
53 | }
54 | }
55 |
56 | // Check whether a request type request matches
57 | protected function matchesRequest(Request $request)
58 | {
59 | return $this->matchesString($this->type, RequestType::REQUEST)
60 | && $this->matchesString($this->uri, $request->uri)
61 | && $this->matchesString($this->controller, $request->controller)
62 | && $this->matchesExact($this->method, strtolower($request->method))
63 | && $this->matchesNumber($this->status, $request->responseStatus)
64 | && $this->matchesNumber($this->time, $request->responseDuration)
65 | && $this->matchesDate($this->received, $request->time);
66 | }
67 |
68 | // Check whether a command type request matches
69 | protected function matchesCommand(Request $request)
70 | {
71 | return $this->matchesString($this->type, RequestType::COMMAND)
72 | && $this->matchesString($this->name, $request->commandName)
73 | && $this->matchesNumber($this->status, $request->commandExitCode)
74 | && $this->matchesNumber($this->time, $request->responseDuration)
75 | && $this->matchesDate($this->received, $request->time);
76 | }
77 |
78 | // Check whether a queue-job type request matches
79 | protected function matchesQueueJob(Request $request)
80 | {
81 | return $this->matchesString($this->type, RequestType::QUEUE_JOB)
82 | && $this->matchesString($this->name, $request->jobName)
83 | && $this->matchesString($this->status, $request->jobStatus)
84 | && $this->matchesNumber($this->time, $request->responseDuration)
85 | && $this->matchesDate($this->received, $request->time);
86 | }
87 |
88 | // Check whether a test type request matches
89 | protected function matchesTest(Request $request)
90 | {
91 | return $this->matchesString($this->type, RequestType::TEST)
92 | && $this->matchesString($this->name, $request->testName)
93 | && $this->matchesString($this->status, $request->testStatus)
94 | && $this->matchesNumber($this->time, $request->responseDuration)
95 | && $this->matchesDate($this->received, $request->time);
96 | }
97 |
98 | // Check if there are no search parameters specified
99 | public function isEmpty()
100 | {
101 | return ! count($this->uri) && ! count($this->controller) && ! count($this->method) && ! count($this->status)
102 | && ! count($this->time) && ! count($this->received) && ! count($this->name) && ! count($this->type);
103 | }
104 |
105 | // Check if there are some search parameters specified
106 | public function isNotEmpty()
107 | {
108 | return ! $this->isEmpty();
109 | }
110 |
111 | // Check if the value matches date type search parameter
112 | protected function matchesDate($inputs, $value)
113 | {
114 | if (! count($inputs)) return true;
115 |
116 | foreach ($inputs as $input) {
117 | if (preg_match('/^<(.+)$/', $input, $match)) {
118 | if ($value < strtotime($match[1])) return true;
119 | } elseif (preg_match('/^>(.+)$/', $input, $match)) {
120 | if ($value > strtotime($match[1])) return true;
121 | }
122 | }
123 |
124 | return false;
125 | }
126 |
127 | // Check if the value matches exact type search parameter
128 | protected function matchesExact($inputs, $value)
129 | {
130 | if (! count($inputs)) return true;
131 |
132 | return in_array($value, $inputs);
133 | }
134 |
135 | // Check if the value matches number type search parameter
136 | protected function matchesNumber($inputs, $value)
137 | {
138 | if (! count($inputs)) return true;
139 |
140 | foreach ($inputs as $input) {
141 | if (preg_match('/^<(\d+(?:\.\d+)?)$/', $input, $match)) {
142 | if ($value < $match[1]) return true;
143 | } elseif (preg_match('/^>(\d+(?:\.\d+)?)$/', $input, $match)) {
144 | if ($value > $match[1]) return true;
145 | } elseif (preg_match('/^(\d+(?:\.\d+)?)-(\d+(?:\.\d+)?)$/', $input, $match)) {
146 | if ($match[1] < $value && $value < $match[2]) return true;
147 | } else {
148 | if ($value == $input) return true;
149 | }
150 | }
151 |
152 | return false;
153 | }
154 |
155 | // Check if the value matches string type search parameter
156 | protected function matchesString($inputs, $value)
157 | {
158 | if (! count($inputs)) return true;
159 |
160 | foreach ($inputs as $input) {
161 | if (strpos($value, $input) !== false) return true;
162 | }
163 |
164 | return false;
165 | }
166 | }
167 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/DBALDataSource.php:
--------------------------------------------------------------------------------
1 | connection = $connection;
30 | $this->connectionName = $this->connection->getDatabase();
31 |
32 | $configuration = $this->connection->getConfiguration();
33 | $currentLogger = $configuration->getSQLLogger();
34 |
35 | if ($currentLogger === null) {
36 | $configuration->setSQLLogger($this);
37 | } else {
38 | $loggerChain = new LoggerChain;
39 | $loggerChain->addLogger($currentLogger);
40 | $loggerChain->addLogger($this);
41 |
42 | $configuration->setSQLLogger($loggerChain);
43 | }
44 | }
45 |
46 | // Adds executed database queries to the request
47 | public function resolve(Request $request)
48 | {
49 | $request->databaseQueries = array_merge($request->databaseQueries, $this->queries);
50 |
51 | return $request;
52 | }
53 |
54 | // Reset the data source to an empty state, clearing any collected data
55 | public function reset()
56 | {
57 | $this->queries = [];
58 | $this->query = null;
59 | }
60 |
61 | // DBAL SQLLogger event
62 | public function startQuery($sql, array $params = null, array $types = null)
63 | {
64 | $this->query = [
65 | 'query' => $sql,
66 | 'params' => $params,
67 | 'types' => $types,
68 | 'time' => microtime(true)
69 | ];
70 | }
71 |
72 | // DBAL SQLLogger event
73 | public function stopQuery()
74 | {
75 | $this->registerQuery($this->query);
76 | $this->query = null;
77 | }
78 |
79 | // Collect an executed database query
80 | protected function registerQuery($query)
81 | {
82 | $query = [
83 | 'query' => $this->createRunnableQuery($query['query'], $query['params'], $query['types']),
84 | 'bindings' => $query['params'],
85 | 'duration' => (microtime(true) - $query['time']) * 1000,
86 | 'connection' => $this->connectionName,
87 | 'time' => $query['time']
88 | ];
89 |
90 | if ($this->passesFilters([ $query ])) {
91 | $this->queries[] = $query;
92 | }
93 | }
94 |
95 | // Takes a query, an array of params and types as arguments, returns runnable query with upper-cased keywords
96 | protected function createRunnableQuery($query, $params, $types)
97 | {
98 | // add params to query
99 | $query = $this->replaceParams($this->connection->getDatabasePlatform(), $query, $params, $types);
100 |
101 | // highlight keywords
102 | $keywords = [
103 | 'select', 'insert', 'update', 'delete', 'into', 'values', 'set', 'where', 'from', 'limit', 'is', 'null',
104 | 'having', 'group by', 'order by', 'asc', 'desc'
105 | ];
106 | $regexp = '/\b' . implode('\b|\b', $keywords) . '\b/i';
107 |
108 | return preg_replace_callback($regexp, function ($match) { return strtoupper($match[0]); }, $query);
109 | }
110 |
111 | /**
112 | * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::format().
113 | *
114 | * @param AbstractPlatform $platform
115 | * @param string $sql
116 | * @param array|null $params
117 | * @param array|null $types
118 | *
119 | *
120 | * @return string
121 | */
122 | public function replaceParams($platform, $sql, array $params = null, array $types = null)
123 | {
124 | if (is_array($params)) {
125 | foreach ($params as $key => $param) {
126 | $type = isset($types[$key]) ? $types[$key] : null; // Originally used null coalescing
127 | $param = $this->convertParam($platform, $param, $type);
128 | $sql = preg_replace('/\?/', "$param", $sql, 1);
129 | }
130 | }
131 | return $sql;
132 | }
133 |
134 | /**
135 | * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::convertParam().
136 | *
137 | * @param mixed $param
138 | *
139 | * @throws \Exception
140 | * @return string
141 | */
142 | protected function convertParam($platform, $param, $type = null)
143 | {
144 | if (is_object($param)) {
145 | if (!method_exists($param, '__toString')) {
146 | if ($param instanceof \DateTimeInterface) {
147 | $param = $param->format('Y-m-d H:i:s');
148 | } elseif (Type::hasType($type)) {
149 | $type = Type::getType($type);
150 | $param = $type->convertToDatabaseValue($param, $platform);
151 | } else {
152 | throw new \Exception('Given query param is an instance of ' . get_class($param) . ' and could not be converted to a string');
153 | }
154 | }
155 | } elseif (is_array($param)) {
156 | if ($this->isNestedArray($param)) {
157 | $param = json_encode($param, JSON_UNESCAPED_UNICODE);
158 | } else {
159 | $param = implode(
160 | ', ',
161 | array_map(
162 | function ($part) {
163 | return '"' . (string) $part . '"';
164 | },
165 | $param
166 | )
167 | );
168 | return '(' . $param . ')';
169 | }
170 | } else {
171 | $param = htmlspecialchars((string) $param); // Originally used the e() Laravel helper
172 | }
173 | return '"' . (string) $param . '"';
174 | }
175 |
176 | /**
177 | * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::isNestedArray().
178 | *
179 | * @param array $array
180 | * @return bool
181 | */
182 | private function isNestedArray(array $array)
183 | {
184 | foreach ($array as $key => $value) {
185 | if (is_array($value)) {
186 | return true;
187 | }
188 | }
189 | return false;
190 | }
191 | }
192 |
--------------------------------------------------------------------------------
/Clockwork/Storage/SqlSearch.php:
--------------------------------------------------------------------------------
1 | pdo = $pdo;
26 |
27 | list($this->conditions, $this->bindings) = $this->resolveConditions();
28 |
29 | $this->buildQuery();
30 | }
31 |
32 | // Creates a new instance from a base Search class instance
33 | public static function fromBase(Search $search = null, PDO $pdo = null)
34 | {
35 | return new static((array) $search, $pdo);
36 | }
37 |
38 | // Add an additional where condition, takes the SQL condition and array of bindings
39 | public function addCondition($condition, $bindings = [])
40 | {
41 | $this->conditions = array_merge([ $condition ], $this->conditions);
42 | $this->bindings = array_merge($bindings, $this->bindings);
43 | $this->buildQuery();
44 |
45 | return $this;
46 | }
47 |
48 | // Resolve SQL conditions and bindings based on the search parameters
49 | protected function resolveConditions()
50 | {
51 | if ($this->isEmpty()) return [ [], [] ];
52 |
53 | $conditions = array_filter([
54 | $this->resolveStringCondition([ 'type' ], $this->type),
55 | $this->resolveStringCondition([ 'uri', 'commandName', 'jobName', 'testName' ], array_merge($this->uri, $this->name)),
56 | $this->resolveStringCondition([ 'controller' ], $this->controller),
57 | $this->resolveExactCondition('method', $this->method),
58 | $this->resolveNumberCondition([ 'responseStatus', 'commandExitCode', 'jobStatus', 'testStatus' ], $this->status),
59 | $this->resolveNumberCondition([ 'responseDuration' ], $this->time),
60 | $this->resolveDateCondition([ 'time' ], $this->received)
61 | ]);
62 |
63 | $sql = array_map(function ($condition) { return $condition[0]; }, $conditions);
64 | $bindings = array_reduce($conditions, function ($bindings, $condition) {
65 | return array_merge($bindings, $condition[1]);
66 | }, []);
67 |
68 | return [ $sql, $bindings ];
69 | }
70 |
71 | // Resolve a date type condition and bindings
72 | protected function resolveDateCondition($fields, $inputs)
73 | {
74 | if (! count($inputs)) return null;
75 |
76 | $bindings = [];
77 | $conditions = implode(' OR ', array_map(function ($field) use ($inputs, &$bindings) {
78 | return implode(' OR ', array_map(function ($input, $index) use ($field, &$bindings) {
79 | if (preg_match('/^<(.+)$/', $input, $match)) {
80 | $bindings["{$field}{$index}"] = $match[1];
81 | return $this->quote($field) . " < :{$field}{$index}";
82 | } elseif (preg_match('/^>(.+)$/', $input, $match)) {
83 | $bindings["{$field}{$index}"] = $match[1];
84 | return $this->quote($field). " > :{$field}{$index}";
85 | }
86 | }, $inputs, array_keys($inputs)));
87 | }, $fields));
88 |
89 | return [ "({$conditions})", $bindings ];
90 | }
91 |
92 | // Resolve an exact type condition and bindings
93 | protected function resolveExactCondition($field, $inputs)
94 | {
95 | if (! count($inputs)) return null;
96 |
97 | $bindings = [];
98 | $values = implode(', ', array_map(function ($input, $index) use ($field, &$bindings) {
99 | $bindings["{$field}{$index}"] = $input;
100 | return ":{$field}{$index}";
101 | }, $inputs, array_keys($inputs)));
102 |
103 | return [ $this->quote($field) . " IN ({$values})", $bindings ];
104 | }
105 |
106 | // Resolve a number type condition and bindings
107 | protected function resolveNumberCondition($fields, $inputs)
108 | {
109 | if (! count($inputs)) return null;
110 |
111 | $bindings = [];
112 | $conditions = implode(' OR ', array_map(function ($field) use ($inputs, &$bindings) {
113 | return implode(' OR ', array_map(function ($input, $index) use ($field, &$bindings) {
114 | if (preg_match('/^<(\d+(?:\.\d+)?)$/', $input, $match)) {
115 | $bindings["{$field}{$index}"] = $match[1];
116 | return $this->quote($field) . " < :{$field}{$index}";
117 | } elseif (preg_match('/^>(\d+(?:\.\d+)?)$/', $input, $match)) {
118 | $bindings["{$field}{$index}"] = $match[1];
119 | return $this->quote($field) . " > :{$field}{$index}";
120 | } elseif (preg_match('/^(\d+(?:\.\d+)?)-(\d+(?:\.\d+)?)$/', $input, $match)) {
121 | $bindings["{$field}{$index}from"] = $match[1];
122 | $bindings["{$field}{$index}to"] = $match[2];
123 | $quotedField = $this->quote($field);
124 | return "({$quotedField} > :{$field}{$index}from AND {$quotedField} < :{$field}{$index}to)";
125 | } else {
126 | $bindings["{$field}{$index}"] = $input;
127 | return $this->quote($field) . " = :{$field}{$index}";
128 | }
129 | }, $inputs, array_keys($inputs)));
130 | }, $fields));
131 |
132 | return [ "({$conditions})", $bindings ];
133 | }
134 |
135 | // Resolve a string type condition and bindings
136 | protected function resolveStringCondition($fields, $inputs)
137 | {
138 | if (! count($inputs)) return null;
139 |
140 | $bindings = [];
141 | $conditions = implode(' OR ', array_map(function ($field) use ($inputs, &$bindings) {
142 | return implode(' OR ', array_map(function ($input, $index) use ($field, &$bindings) {
143 | $bindings["{$field}{$index}"] = $input;
144 | return $this->quote($field) . " LIKE :{$field}{$index}";
145 | }, $inputs, array_keys($inputs)));
146 | }, $fields));
147 |
148 | return [ "({$conditions})", $bindings ];
149 | }
150 |
151 | // Build the where part of the SQL query
152 | protected function buildQuery()
153 | {
154 | $this->query = count($this->conditions) ? 'WHERE ' . implode(' AND ', $this->conditions) : '';
155 | }
156 |
157 | // Quotes SQL identifier name properly for the current database
158 | protected function quote($identifier)
159 | {
160 | return $this->pdo && $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql' ? "`{$identifier}`" : "\"{$identifier}\"";
161 | }
162 | }
163 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/GuzzleDataSource.php:
--------------------------------------------------------------------------------
1 | collectContent = $collectContent;
30 | $this->collectRawContent = $collectRawContent;
31 | }
32 |
33 | // Returns a new Guzzle instance, pre-configured with Clockwork support
34 | public function instance(array $config = [])
35 | {
36 | return new Client($this->configure($config));
37 | }
38 |
39 | // Updates Guzzle configuration array with Clockwork support
40 | public function configure(array $config = [])
41 | {
42 | $handler = isset($config['handler']) ? $config['handler'] : HandlerStack::create();
43 |
44 | $handler->push($this);
45 |
46 | $config['handler'] = $handler;
47 |
48 | return $config;
49 | }
50 |
51 | // Add sent notifications to the request
52 | public function resolve(Request $request)
53 | {
54 | $request->httpRequests = array_merge($request->httpRequests, $this->requests);
55 |
56 | return $request;
57 | }
58 |
59 | // Reset the data source to an empty state, clearing any collected data
60 | public function reset()
61 | {
62 | $this->requests = [];
63 | $this->executingRequests = [];
64 | }
65 |
66 | // Guzzle middleware implemenation, that does the requests logging itself
67 | public function __invoke(callable $handler): callable
68 | {
69 | return function(RequestInterface $request, array $options) use ($handler): PromiseInterface {
70 | $time = microtime(true);
71 | $stats = null;
72 |
73 | $originalOnStats = isset($options['on_stats']) ? $options['on_stats'] : null;
74 | $options['on_stats'] = function (TransferStats $transferStats) use (&$stats, $originalOnStats) {
75 | $stats = $transferStats->getHandlerStats();
76 | if ($originalOnStats) $originalOnStats($transferStats);
77 | };
78 |
79 | return $handler($request, $options)
80 | ->then(function(ResponseInterface $response) use ($request, $time, $stats) {
81 | $this->collectRequest($request, $response, $time, $stats);
82 |
83 | return $response;
84 | }, function(GuzzleException $exception) use ($request, $time, $stats) {
85 | $response = $exception instanceof RequestException ? $exception->getResponse() : null;
86 | $this->collectRequest($request, $response, $time, $stats);
87 |
88 | throw $exception;
89 | });
90 | };
91 | }
92 |
93 | // Collect a request-response pair
94 | protected function collectRequest($request, $response = null, $startTime = null, $stats = null)
95 | {
96 | $trace = StackTrace::get();
97 |
98 | $request = (object) [
99 | 'request' => (object) [
100 | 'method' => $request->getMethod(),
101 | 'url' => $this->removeAuthFromUrl((string) $request->getUri()),
102 | 'headers' => $request->getHeaders(),
103 | 'content' => $this->collectContent ? $this->resolveRequestContent($request) : null,
104 | 'body' => $this->collectRawContent ? (string) $request->getBody() : null
105 | ],
106 | 'response' => (object) [
107 | 'status' => (int) $response->getStatusCode(),
108 | 'headers' => $response->getHeaders(),
109 | 'content' => $this->collectContent ? json_decode((string) $response->getBody(), true) : null,
110 | 'body' => $this->collectRawContent ? (string) $response->getBody() : null
111 | ],
112 | 'stats' => $stats ? (object) [
113 | 'timing' => isset($stats['total_time_us']) ? (object) [
114 | 'lookup' => $stats['namelookup_time_us'] / 1000,
115 | 'connect' => ($stats['pretransfer_time_us'] - $stats['namelookup_time_us']) / 1000,
116 | 'waiting' => ($stats['starttransfer_time_us'] - $stats['pretransfer_time_us']) / 1000,
117 | 'transfer' => ($stats['total_time_us'] - $stats['starttransfer_time_us']) / 1000
118 | ] : null,
119 | 'size' => (object) [
120 | 'upload' => isset($stats['size_upload']) ? $stats['size_upload'] : null,
121 | 'download' => isset($stats['size_download']) ? $stats['size_download'] : null
122 | ],
123 | 'speed' => (object) [
124 | 'upload' => isset($stats['speed_upload']) ? $stats['speed_upload'] : null,
125 | 'download' => isset($stats['speed_download']) ? $stats['speed_download'] : null
126 | ],
127 | 'hosts' => (object) [
128 | 'local' => isset($stats['local_ip']) ? [ 'ip' => $stats['local_ip'], 'port' => $stats['local_port'] ] : null,
129 | 'remote' => isset($stats['primary_ip']) ? [ 'ip' => $stats['primary_ip'], 'port' => $stats['primary_port'] ] : null
130 | ],
131 | 'version' => isset($stats['http_version']) ? $stats['http_version'] : null
132 | ] : null,
133 | 'error' => null,
134 | 'time' => $startTime,
135 | 'duration' => (microtime(true) - $startTime) * 1000,
136 | 'trace' => (new Serializer)->trace($trace)
137 | ];
138 |
139 | if ($this->passesFilters([ $request ])) {
140 | $this->requests[] = $request;
141 | }
142 | }
143 |
144 | // Resolve request content, with support for form data and json requests
145 | protected function resolveRequestContent($request)
146 | {
147 | $body = (string) $request->getBody();
148 | $headers = $request->getHeaders();
149 |
150 | if (isset($headers['Content-Type']) && $headers['Content-Type'][0] == 'application/x-www-form-urlencoded') {
151 | parse_str($body, $parameters);
152 | return $parameters;
153 | } elseif (isset($headers['Content-Type']) && strpos($headers['Content-Type'][0], 'json') !== false) {
154 | return json_decode($body, true);
155 | }
156 |
157 | return [];
158 | }
159 |
160 | // Removes username and password from the URL
161 | protected function removeAuthFromUrl($url)
162 | {
163 | return preg_replace('#^(.+?://)(.+?@)(.*)$#', '$1$3', $url);
164 | }
165 | }
166 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/LumenDataSource.php:
--------------------------------------------------------------------------------
1 | app = $app;
33 |
34 | $this->collectLog = $collectLog;
35 | $this->collectRoutes = $collectRoutes;
36 |
37 | $this->log = new Log;
38 | }
39 |
40 | // Adds request, response information, middleware, routes, session data, user and log entries to the request
41 | public function resolve(Request $request)
42 | {
43 | $request->method = $this->getRequestMethod();
44 | $request->uri = $this->getRequestUri();
45 | $request->controller = $this->getController();
46 | $request->headers = $this->getRequestHeaders();
47 | $request->responseStatus = $this->getResponseStatus();
48 | $request->routes = $this->getRoutes();
49 | $request->sessionData = $this->getSessionData();
50 |
51 | $this->resolveAuthenticatedUser($request);
52 |
53 | $request->log()->merge($this->log);
54 |
55 | return $request;
56 | }
57 |
58 | // Reset the data source to an empty state, clearing any collected data
59 | public function reset()
60 | {
61 | $this->log = new Log;
62 | }
63 |
64 | // Set Lumen response instance for the current request
65 | public function setResponse(Response $response)
66 | {
67 | $this->response = $response;
68 | return $this;
69 | }
70 |
71 | // Listen for the log events
72 | public function listenToEvents()
73 | {
74 | if (! $this->collectLog) return;
75 |
76 | if (class_exists(\Illuminate\Log\Events\MessageLogged::class)) {
77 | // Lumen 5.4
78 | $this->app['events']->listen(\Illuminate\Log\Events\MessageLogged::class, function ($event) {
79 | $this->log->log($event->level, $event->message, $event->context);
80 | });
81 | } else {
82 | // Lumen 5.0 to 5.3
83 | $this->app['events']->listen('illuminate.log', function ($level, $message, $context) {
84 | $this->log->log($level, $message, $context);
85 | });
86 | }
87 | }
88 |
89 | // Get a textual representation of current route's controller
90 | protected function getController()
91 | {
92 | $routes = method_exists($this->app, 'getRoutes') ? $this->app->getRoutes() : [];
93 |
94 | $method = $this->getRequestMethod();
95 | $pathInfo = $this->getPathInfo();
96 |
97 | if (isset($routes[$method.$pathInfo]['action']['uses'])) {
98 | $controller = $routes[$method.$pathInfo]['action']['uses'];
99 | } elseif (isset($routes[$method.$pathInfo]['action'][0])) {
100 | $controller = $routes[$method.$pathInfo]['action'][0];
101 | } else {
102 | $controller = null;
103 | }
104 |
105 | if ($controller instanceof \Closure) {
106 | $controller = 'anonymous function';
107 | } elseif (is_object($controller)) {
108 | $controller = 'instance of ' . get_class($controller);
109 | } elseif (! is_string($controller)) {
110 | $controller = null;
111 | }
112 |
113 | return $controller;
114 | }
115 |
116 | // Get the request headers
117 | protected function getRequestHeaders()
118 | {
119 | return $this->app['request']->headers->all();
120 | }
121 |
122 | // Get the request method
123 | protected function getRequestMethod()
124 | {
125 | if ($this->app->bound('request')) {
126 | return $this->app['request']->getMethod();
127 | } elseif (isset($_POST['_method'])) {
128 | return strtoupper($_POST['_method']);
129 | } else {
130 | return $_SERVER['REQUEST_METHOD'];
131 | }
132 | }
133 |
134 | // Get the request URI
135 | protected function getRequestUri()
136 | {
137 | return $this->app['request']->getRequestUri();
138 | }
139 |
140 | // Get the response status code
141 | protected function getResponseStatus()
142 | {
143 | return $this->response ? $this->response->getStatusCode() : null;
144 | }
145 |
146 | // Get an array of application routes
147 | protected function getRoutes()
148 | {
149 | if (! $this->collectRoutes) return [];
150 |
151 | if (isset($this->app->router)) {
152 | $routes = array_values($this->app->router->getRoutes());
153 | } elseif (method_exists($this->app, 'getRoutes')) {
154 | $routes = array_values($this->app->getRoutes());
155 | } else {
156 | $routes = [];
157 | }
158 |
159 | return array_map(function ($route) {
160 | return [
161 | 'method' => $route['method'],
162 | 'uri' => $route['uri'],
163 | 'name' => isset($route['action']['as']) ? $route['action']['as'] : null,
164 | 'action' => isset($route['action']['uses']) && is_string($route['action']['uses']) ? $route['action']['uses'] : 'anonymous function',
165 | 'middleware' => isset($route['action']['middleware']) ? $route['action']['middleware'] : null,
166 | ];
167 | }, $routes);
168 | }
169 |
170 | // Get the session data (normalized with passwords removed)
171 | protected function getSessionData()
172 | {
173 | if (! isset($this->app['session'])) return [];
174 |
175 | return $this->removePasswords((new Serializer)->normalizeEach($this->app['session']->all()));
176 | }
177 |
178 | // Add authenticated user data to the request
179 | protected function resolveAuthenticatedUser(Request $request)
180 | {
181 | if (! isset($this->app['auth'])) return;
182 | if (! ($user = $this->app['auth']->user())) return;
183 | if (! isset($user->email) || ! isset($user->id)) return;
184 |
185 | $request->setAuthenticatedUser($user->email, $user->id, [
186 | 'email' => $user->email,
187 | 'name' => isset($user->name) ? $user->name : null
188 | ]);
189 | }
190 |
191 | // Get the request path info
192 | protected function getPathInfo()
193 | {
194 | if ($this->app->bound('request')) {
195 | return $this->app['request']->getPathInfo();
196 | } else {
197 | $query = isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : '';
198 | return '/' . trim(str_replace("?{$query}", '', $_SERVER['REQUEST_URI']), '/');
199 | }
200 | }
201 | }
202 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 | 
4 |
5 |
6 | > Clockwork is a development tool for PHP available right in your browser. Clockwork gives you an insight into your application runtime - including request data, performance metrics, log entries, database queries, cache queries, redis commands, dispatched events, queued jobs, rendered views and more - for HTTP requests, commands, queue jobs and tests.
7 |
8 | > *This repository contains the server-side component of Clockwork.*
9 |
10 | > Check out on the [Clockwork website](https://underground.works/clockwork) for details.
11 |
12 |
13 |
14 | 
15 |
16 |
17 | 
18 |
19 |
20 | 
21 |
22 |
23 | 
24 |
25 |
26 | 
27 |
28 |
29 | 
30 |
31 |
32 | 
33 |
34 |
35 | 
36 |
37 |
38 |
39 | ### Installation
40 |
41 | Install the Clockwork library via [Composer](https://getcomposer.org/).
42 |
43 | ```
44 | composer require itsgoingd/clockwork
45 | ```
46 |
47 | Congratulations, you are done! To enable more features like commands or queue jobs profiling, publish the configuration file via the `vendor:publish` Artisan command.
48 |
49 | **Note:** If you are using the Laravel route cache, you will need to refresh it using the route:cache Artisan command.
50 |
51 | Read [full installation instructions](https://underground.works/clockwork/#docs-installation) on the Clockwork website.
52 |
53 | ### Features
54 |
55 | #### Collecting data
56 |
57 | The Clockwork server-side component collects and stores data about your application.
58 |
59 | Clockwork is only active when your app is in debug mode by default. You can choose to explicitly enable or disable Clockwork, or even set Clockwork to always collect data without exposing them for further analysis.
60 |
61 | We collect a whole bunch of useful data by default, but you can enable more features or disable features you don't need in the config file.
62 |
63 | Some features might allow for advanced options, eg. for database queries you can set a slow query threshold or enable detecting of duplicate (N+1) queries. Check out the config file to see all what Clockwork can do.
64 |
65 | There are several options that allow you to choose for which requests Clockwork is active.
66 |
67 | On-demand mode will collect data only when Clockwork app is open. You can even specify a secret to be set in the app settings to collect request. Errors only will record only requests ending with 4xx and 5xx responses. Slow only will collect only requests with responses above the set slow threshold. You can also filter the collected and recorded requests by a custom closure. CORS pre-flight requests will not be collected by default.
68 |
69 | New in Clockwork 4.1, artisan commands, queue jobs and tests can now also be collected, you need to enable this in the config file.
70 |
71 | Clockwork also collects stack traces for data like log messages or database queries. Last 10 frames of the trace are collected by default. You can change the frames limit or disable this feature in the configuration file.
72 |
73 | #### Viewing data
74 |
75 | ##### Web interface
76 |
77 | Visit `/clockwork` route to view and interact with the collected data.
78 |
79 | The app will show all executed requests, which is useful when the request is not made by browser, but for example a mobile application you are developing an API for.
80 |
81 | ##### Browser extension
82 |
83 | A browser dev tools extension is also available for Chrome and Firefox:
84 |
85 | - [Chrome Web Store](https://chrome.google.com/webstore/detail/clockwork/dmggabnehkmmfmdffgajcflpdjlnoemp)
86 | - [Firefox Addons](https://addons.mozilla.org/en-US/firefox/addon/clockwork-dev-tools/)
87 |
88 | ##### Toolbar
89 |
90 | Clockwork now gives you an option to show basic request information in the form of a toolbar in your app.
91 |
92 | The toolbar is fully rendered client-side and requires installing a tiny javascript library.
93 |
94 | [Learn more](https://underground.works/clockwork/#docs-viewing-data) on the Clockwork website.
95 |
96 | #### Logging
97 |
98 | You can log any variable via the clock() helper, from a simple string to an array or object, even multiple values:
99 |
100 | ```php
101 | clock(User::first(), auth()->user(), $username)
102 | ```
103 |
104 | The `clock()` helper function returns it's first argument, so you can easily add inline debugging statements to your code:
105 |
106 | ```php
107 | User::create(clock($request->all()))
108 | ```
109 |
110 | If you want to specify a log level, you can use the long-form call:
111 |
112 | ```php
113 | clock()->info("User {$username} logged in!")
114 | ```
115 |
116 | #### Timeline
117 |
118 | Timeline gives you a visual representation of your application runtime.
119 |
120 | To add an event to the timeline - start it with a description, execute the tracked code and finish the event. A fluent api is available to further configure the event.
121 |
122 | ```php
123 | // using timeline api with begin/end and fluent configuration
124 | clock()->event('Importing tweets')->color('purple')->begin();
125 | ...
126 | clock()->event('Importing tweets')->end();
127 | ```
128 |
129 | Alternatively you can execute the tracked code block as a closure. You can also choose to use an array based configuration instead of the fluent api.
130 |
131 | ```php
132 | // using timeline api with run and array-based configuration
133 | clock()->event('Updating cache', [ 'color' => 'green' ])->run(function () {
134 | ...
135 | });
136 | ```
137 |
138 | Read more about available features on the [Clockwork website](https://underground.works/clockwork).
139 |
140 |
141 |
142 | 
143 |
144 |
145 |
--------------------------------------------------------------------------------
/Clockwork/DataSource/LaravelDataSource.php:
--------------------------------------------------------------------------------
1 | app = $app;
36 |
37 | $this->collectLog = $collectLog;
38 | $this->collectRoutes = $collectRoutes;
39 | $this->routesOnlyNamespaces = $routesOnlyNamespaces;
40 |
41 | $this->log = new Log;
42 | }
43 |
44 | // Adds request, response information, middleware, routes, session data, user and log entries to the request
45 | public function resolve(Request $request)
46 | {
47 | $request->method = $this->getRequestMethod();
48 | $request->url = $this->getRequestUrl();
49 | $request->uri = $this->getRequestUri();
50 | $request->controller = $this->getController();
51 | $request->headers = $this->getRequestHeaders();
52 | $request->responseStatus = $this->getResponseStatus();
53 | $request->middleware = $this->getMiddleware();
54 | $request->routes = $this->getRoutes();
55 | $request->sessionData = $this->getSessionData();
56 |
57 | $this->resolveAuthenticatedUser($request);
58 |
59 | $request->log()->merge($this->log);
60 |
61 | return $request;
62 | }
63 |
64 | // Reset the data source to an empty state, clearing any collected data
65 | public function reset()
66 | {
67 | $this->log = new Log;
68 | }
69 |
70 | // Set Laravel application instance for the current request
71 | public function setApplication(Application $app)
72 | {
73 | $this->app = $app;
74 | return $this;
75 | }
76 |
77 | // Set Laravel response instance for the current request
78 | public function setResponse(Response $response)
79 | {
80 | $this->response = $response;
81 | return $this;
82 | }
83 |
84 | // Listen for the log events
85 | public function listenToEvents()
86 | {
87 | if (! $this->collectLog) return;
88 |
89 | if (class_exists(\Illuminate\Log\Events\MessageLogged::class)) {
90 | // Laravel 5.4
91 | $this->app['events']->listen(\Illuminate\Log\Events\MessageLogged::class, function ($event) {
92 | $this->log->log($event->level, $event->message, $event->context);
93 | });
94 | } else {
95 | // Laravel 5.0 to 5.3
96 | $this->app['events']->listen('illuminate.log', function ($level, $message, $context) {
97 | $this->log->log($level, $message, $context);
98 | });
99 | }
100 | }
101 |
102 | // Get a textual representation of the current route's controller
103 | protected function getController()
104 | {
105 | $router = $this->app['router'];
106 |
107 | $route = $router->current();
108 | $controller = $route ? $route->getActionName() : null;
109 |
110 | if ($controller instanceof \Closure) {
111 | $controller = 'anonymous function';
112 | } elseif (is_object($controller)) {
113 | $controller = 'instance of ' . get_class($controller);
114 | } elseif (is_array($controller) && count($controller) == 2) {
115 | if (is_object($controller[0])) {
116 | $controller = get_class($controller[0]) . '->' . $controller[1];
117 | } else {
118 | $controller = $controller[0] . '::' . $controller[1];
119 | }
120 | } elseif (! is_string($controller)) {
121 | $controller = null;
122 | }
123 |
124 | return $controller;
125 | }
126 |
127 | // Get the request headers
128 | protected function getRequestHeaders()
129 | {
130 | return $this->app['request']->headers->all();
131 | }
132 |
133 | // Get the request method
134 | protected function getRequestMethod()
135 | {
136 | return $this->app['request']->getMethod();
137 | }
138 |
139 | // Get the request URL
140 | protected function getRequestUrl()
141 | {
142 | return $this->app['request']->fullUrl();
143 | }
144 |
145 | // Get the request URI
146 | protected function getRequestUri()
147 | {
148 | return $this->app['request']->getRequestUri();
149 | }
150 |
151 | // Get the response status code
152 | protected function getResponseStatus()
153 | {
154 | return $this->response ? $this->response->getStatusCode() : null;
155 | }
156 |
157 | // Get an array of middleware for the matched route
158 | protected function getMiddleware()
159 | {
160 | $route = $this->app['router']->current();
161 |
162 | if (! $route) return;
163 |
164 | return method_exists($route, 'gatherMiddleware') ? $route->gatherMiddleware() : $route->middleware();
165 | }
166 |
167 | // Get an array of application routes
168 | protected function getRoutes()
169 | {
170 | if (! $this->collectRoutes) return [];
171 |
172 | return array_values(array_filter(array_map(function ($route) {
173 | $action = $route->getActionName() ?: 'anonymous function';
174 | $namespace = strpos($action, '\\') !== false ? explode('\\', $action)[0] : null;
175 |
176 | if (count($this->routesOnlyNamespaces) && ! in_array($namespace, $this->routesOnlyNamespaces)) return;
177 |
178 | return [
179 | 'method' => implode(', ', $route->methods()),
180 | 'uri' => $route->uri(),
181 | 'name' => $route->getName(),
182 | 'action' => $action,
183 | 'middleware' => $route->middleware(),
184 | 'before' => method_exists($route, 'beforeFilters') ? implode(', ', array_keys($route->beforeFilters())) : '',
185 | 'after' => method_exists($route, 'afterFilters') ? implode(', ', array_keys($route->afterFilters())) : ''
186 | ];
187 | }, $this->app['router']->getRoutes()->getRoutes())));
188 | }
189 |
190 | // Get the session data (normalized with removed passwords)
191 | protected function getSessionData()
192 | {
193 | if (! isset($this->app['session'])) return [];
194 |
195 | return $this->removePasswords((new Serializer)->normalizeEach($this->app['session']->all()));
196 | }
197 |
198 | // Add authenticated user data to the request
199 | protected function resolveAuthenticatedUser(Request $request)
200 | {
201 | if (! isset($this->app['auth'])) return;
202 | if (! ($user = $this->app['auth']->user())) return;
203 |
204 | if ($user instanceof \Illuminate\Database\Eloquent\Model) {
205 | // retrieve attributes in this awkward way to make sure we don't trigger exceptions with Eloquent strict mode on
206 | $keyName = method_exists($user, 'getAuthIdentifierName') ? $user->getAuthIdentifierName() : $user->getKeyName();
207 | $user = $user->getAttributes();
208 |
209 | $userId = isset($user[$keyName]) ? $user[$keyName] : null;
210 | $userEmail = isset($user['email']) ? $user['email'] : $userId;
211 | $userName = isset($user['name']) ? $user['name'] : null;
212 | } else {
213 | $userId = $user->getAuthIdentifier();
214 | $userEmail = isset($user->email) ? $user->email : $userId;
215 | $userName = isset($user->name) ? $user->name : null;
216 | }
217 |
218 | $request->setAuthenticatedUser($userEmail, $userId, [
219 | 'email' => $userEmail,
220 | 'name' => $userName
221 | ]);
222 | }
223 | }
224 |
--------------------------------------------------------------------------------
/Clockwork/Clockwork.php:
--------------------------------------------------------------------------------
1 | request = new Request;
43 | $this->authenticator = new NullAuthenticator;
44 |
45 | $this->shouldCollect = new ShouldCollect;
46 | $this->shouldRecord = new ShouldRecord;
47 | }
48 |
49 | // Add a new data source
50 | public function addDataSource(DataSourceInterface $dataSource)
51 | {
52 | $this->dataSources[] = $dataSource;
53 | return $this;
54 | }
55 |
56 | // Resolve the current request, sending it through all data sources, finalizing log and timeline
57 | public function resolveRequest()
58 | {
59 | foreach ($this->dataSources as $dataSource) {
60 | $dataSource->resolve($this->request);
61 | }
62 |
63 | $this->request->log()->sort();
64 | $this->request->timeline()->finalize($this->request->time);
65 |
66 | return $this;
67 | }
68 |
69 | // Resolve the current request as a "command" type request with command-specific data
70 | public function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)
71 | {
72 | $this->resolveRequest();
73 |
74 | $this->request->type = RequestType::COMMAND;
75 | $this->request->commandName = $name;
76 | $this->request->commandArguments = $arguments;
77 | $this->request->commandArgumentsDefaults = $argumentsDefaults;
78 | $this->request->commandOptions = $options;
79 | $this->request->commandOptionsDefaults = $optionsDefaults;
80 | $this->request->commandExitCode = $exitCode;
81 | $this->request->commandOutput = $output;
82 |
83 | return $this;
84 | }
85 |
86 | // Resolve the current request as a "queue-job" type request with queue-job-specific data
87 | public function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])
88 | {
89 | $this->resolveRequest();
90 |
91 | $this->request->type = RequestType::QUEUE_JOB;
92 | $this->request->jobName = $name;
93 | $this->request->jobDescription = $description;
94 | $this->request->jobStatus = $status;
95 | $this->request->jobPayload = (new Serializer)->normalize($payload);
96 | $this->request->jobQueue = $queue;
97 | $this->request->jobConnection = $connection;
98 | $this->request->jobOptions = (new Serializer)->normalizeEach($options);
99 |
100 | return $this;
101 | }
102 |
103 | // Resolve the current request as a "test" type request with test-specific data, accepts test name, status, status
104 | // message in case of failure and array of ran asserts
105 | public function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = [])
106 | {
107 | $this->resolveRequest();
108 |
109 | $this->request->type = RequestType::TEST;
110 | $this->request->testName = $name;
111 | $this->request->testStatus = $status;
112 | $this->request->testStatusMessage = $statusMessage;
113 |
114 | foreach ($asserts as $assert) {
115 | $this->request->addTestAssert($assert['name'], $assert['arguments'], $assert['passed'], $assert['trace']);
116 | }
117 |
118 | return $this;
119 | }
120 |
121 | // Extends the request with an additional data form all data sources, which is not required for normal use
122 | public function extendRequest(Request $request = null)
123 | {
124 | foreach ($this->dataSources as $dataSource) {
125 | $dataSource->extend($request ?: $this->request);
126 | }
127 |
128 | return $this;
129 | }
130 |
131 | // Store the current request via configured storage implementation
132 | public function storeRequest()
133 | {
134 | return $this->storage->store($this->request);
135 | }
136 |
137 | // Reset all data sources to an empty state, clearing any collected data
138 | public function reset()
139 | {
140 | foreach ($this->dataSources as $dataSource) {
141 | $dataSource->reset();
142 | }
143 |
144 | return $this;
145 | }
146 |
147 | // Get or set the current request instance
148 | public function request(Request $request = null)
149 | {
150 | if (! $request) return $this->request;
151 |
152 | $this->request = $request;
153 | return $this;
154 | }
155 |
156 | // Get the log instance for the current request or log a new message
157 | public function log($level = null, $message = null, array $context = [])
158 | {
159 | if ($level) {
160 | return $this->request->log()->log($level, $message, $context);
161 | }
162 |
163 | return $this->request->log();
164 | }
165 |
166 | // Get the timeline instance for the current request
167 | public function timeline()
168 | {
169 | return $this->request->timeline();
170 | }
171 |
172 | // Shortcut to create a new event on the current timeline instance
173 | public function event($description, $data = [])
174 | {
175 | return $this->request->timeline()->event($description, $data);
176 | }
177 |
178 | // Configure which requests should be collected, can be called with arrey of options, a custom closure or with no
179 | // arguments for a fluent configuration api
180 | public function shouldCollect($shouldCollect = null)
181 | {
182 | if ($shouldCollect instanceof Closure) return $this->shouldCollect->callback($shouldCollect);
183 |
184 | if (is_array($shouldCollect)) return $this->shouldCollect->merge($shouldCollect);
185 |
186 | return $this->shouldCollect;
187 | }
188 |
189 | // Configure which requests should be recorded, can be called with arrey of options, a custom closure or with no
190 | // arguments for a fluent configuration api
191 | public function shouldRecord($shouldRecord = null)
192 | {
193 | if ($shouldRecord instanceof Closure) return $this->shouldRecord->callback($shouldRecord);
194 |
195 | if (is_array($shouldRecord)) return $this->shouldRecord->merge($shouldRecord);
196 |
197 | return $this->shouldRecord;
198 | }
199 |
200 | // Get or set all data sources at once
201 | public function dataSources($dataSources = null)
202 | {
203 | if (! $dataSources) return $this->dataSources;
204 |
205 | $this->dataSources = $dataSources;
206 | return $this;
207 | }
208 |
209 | // Get or set a storage implementation
210 | public function storage(StorageInterface $storage = null)
211 | {
212 | if (! $storage) return $this->storage;
213 |
214 | $this->storage = $storage;
215 | return $this;
216 | }
217 |
218 | // Get or set an authenticator implementation
219 | public function authenticator(AuthenticatorInterface $authenticator = null)
220 | {
221 | if (! $authenticator) return $this->authenticator;
222 |
223 | $this->authenticator = $authenticator;
224 | return $this;
225 | }
226 |
227 | // Forward any other method calls to the current request and log instances
228 | public function __call($method, $args)
229 | {
230 | if (in_array($method, [ 'emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug' ])) {
231 | return $this->request->log()->$method(...$args);
232 | }
233 |
234 | return $this->request->$method(...$args);
235 | }
236 |
237 | // DEPRECATED The following apis are deprecated and will be removed in a future version
238 |
239 | // Get all added data sources
240 | public function getDataSources()
241 | {
242 | return $this->dataSources;
243 | }
244 |
245 | // Get the current request instance
246 | public function getRequest()
247 | {
248 | return $this->request;
249 | }
250 |
251 | // Set the current request instance
252 | public function setRequest(Request $request)
253 | {
254 | $this->request = $request;
255 | return $this;
256 | }
257 |
258 | // Get a storage implementation
259 | public function getStorage()
260 | {
261 | return $this->storage;
262 | }
263 |
264 | // Set a storage implementation
265 | public function setStorage(StorageInterface $storage)
266 | {
267 | $this->storage = $storage;
268 | return $this;
269 | }
270 |
271 | // Get an authenticator implementation
272 | public function getAuthenticator()
273 | {
274 | return $this->authenticator;
275 | }
276 |
277 | // Set an authenticator implementation
278 | public function setAuthenticator(AuthenticatorInterface $authenticator)
279 | {
280 | $this->authenticator = $authenticator;
281 | return $this;
282 | }
283 | }
284 |
--------------------------------------------------------------------------------