Your IP : 216.73.217.77
<?php
namespace Laravel\Telescope;
use Closure;
use Exception;
use Illuminate\Contracts\Debug\ExceptionHandler;
use Illuminate\Log\Events\MessageLogged;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Str;
use Illuminate\Support\Testing\Fakes\EventFake;
use Laravel\Telescope\Contracts\EntriesRepository;
use Laravel\Telescope\Contracts\TerminableRepository;
use Laravel\Telescope\Jobs\ProcessPendingUpdates;
use Throwable;
class Telescope
{
use AuthorizesRequests,
ExtractsMailableTags,
ListensForStorageOpportunities,
RegistersWatchers;
/**
* The callbacks that filter the entries that should be recorded.
*
* @var array
*/
public static $filterUsing = [];
/**
* The callbacks that filter the batches that should be recorded.
*
* @var array
*/
public static $filterBatchUsing = [];
/**
* The callback executed after queuing a new entry.
*
* @var \Closure
*/
public static $afterRecordingHook;
/**
* The callbacks executed after storing the entries.
*
* @var \Closure
*/
public static $afterStoringHooks = [];
/**
* The callbacks that add tags to the record.
*
* @var \Closure[]
*/
public static $tagUsing = [];
/**
* The list of queued entries to be stored.
*
* @var array
*/
public static $entriesQueue = [];
/**
* The list of queued entry updates.
*
* @var array
*/
public static $updatesQueue = [];
/**
* The list of hidden request headers.
*
* @var array
*/
public static $hiddenRequestHeaders = [
'authorization',
'php-auth-pw',
];
/**
* The list of hidden request parameters.
*
* @var array
*/
public static $hiddenRequestParameters = [
'password',
'password_confirmation',
];
/**
* The list of hidden response parameters.
*
* @var array
*/
public static $hiddenResponseParameters = [];
/**
* Indicates if Telescope should ignore events fired by Laravel.
*
* @var bool
*/
public static $ignoreFrameworkEvents = true;
/**
* Indicates if Telescope should use the dark theme.
*
* @var bool
*/
public static $useDarkTheme = false;
/**
* Indicates if Telescope should record entries.
*
* @var bool
*/
public static $shouldRecord = false;
/**
* Indicates if Telescope migrations will be run.
*
* @var bool
*/
public static $runsMigrations = true;
/**
* Register the Telescope watchers and start recording if necessary.
*
* @param \Illuminate\Foundation\Application $app
* @return void
*/
public static function start($app)
{
if (! config('telescope.enabled')) {
return;
}
static::registerWatchers($app);
static::registerMailableTagExtractor();
if (! static::runningWithinOctane($app) &&
(static::runningApprovedArtisanCommand($app) ||
static::handlingApprovedRequest($app))
) {
static::startRecording($loadMonitoredTags = false);
}
}
/**
* Determine if Telescope is running within Octane.
*
* @param \Illuminate\Foundation\Application $app
* @return bool
*/
protected static function runningWithinOctane($app)
{
return isset($_SERVER['LARAVEL_OCTANE']);
}
/**
* Determine if the application is running an approved command.
*
* @param \Illuminate\Foundation\Application $app
* @return bool
*/
protected static function runningApprovedArtisanCommand($app)
{
return $app->runningInConsole() && ! in_array(
$_SERVER['argv'][1] ?? null,
array_merge([
// 'migrate',
'migrate:rollback',
'migrate:fresh',
// 'migrate:refresh',
'migrate:reset',
'migrate:install',
'package:discover',
'queue:listen',
'queue:work',
'horizon',
'horizon:work',
'horizon:supervisor',
], config('telescope.ignoreCommands', []), config('telescope.ignore_commands', []))
);
}
/**
* Determine if the application is handling an approved request.
*
* @param \Illuminate\Foundation\Application $app
* @return bool
*/
protected static function handlingApprovedRequest($app)
{
if ($app->runningInConsole()) {
return false;
}
return static::requestIsToApprovedDomain($app['request']) &&
static::requestIsToApprovedUri($app['request']);
}
/**
* Determine if the request is to an approved domain.
*
* @param \Illuminate\Http\Request $request
* @return bool
*/
protected static function requestIsToApprovedDomain($request): bool
{
return is_null(config('telescope.domain')) ||
config('telescope.domain') !== $request->getHost();
}
/**
* Determine if the request is to an approved URI.
*
* @param \Illuminate\Http\Request $request
* @return bool
*/
protected static function requestIsToApprovedUri($request)
{
if (! empty($only = config('telescope.only_paths', []))) {
return $request->is($only);
}
return ! $request->is(
collect([
'telescope-api*',
'vendor/telescope*',
(config('horizon.path') ?? 'horizon').'*',
'vendor/horizon*',
])
->merge(config('telescope.ignore_paths', []))
->unless(is_null(config('telescope.path')), function ($paths) {
return $paths->prepend(config('telescope.path').'*');
})
->all()
);
}
/**
* Start recording entries.
*
* @param bool $loadMonitoredTags
* @return void
*/
public static function startRecording($loadMonitoredTags = true)
{
if ($loadMonitoredTags) {
app(EntriesRepository::class)->loadMonitoredTags();
}
$recordingPaused = false;
try {
$recordingPaused = cache('telescope:pause-recording');
} catch (Exception) {
//
}
static::$shouldRecord = ! $recordingPaused;
}
/**
* Stop recording entries.
*
* @return void
*/
public static function stopRecording()
{
static::$shouldRecord = false;
}
/**
* Execute the given callback without recording Telescope entries.
*
* @param callable $callback
* @return mixed
*/
public static function withoutRecording($callback)
{
$shouldRecord = static::$shouldRecord;
static::$shouldRecord = false;
try {
return call_user_func($callback);
} finally {
static::$shouldRecord = $shouldRecord;
}
}
/**
* Determine if Telescope is recording.
*
* @return bool
*/
public static function isRecording()
{
return static::$shouldRecord && ! app('events') instanceof EventFake;
}
/**
* Record the given entry.
*
* @param string $type
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
protected static function record(string $type, IncomingEntry $entry)
{
if (! static::isRecording()) {
return;
}
try {
if (Auth::hasResolvedGuards() && Auth::hasUser()) {
$entry->user(Auth::user());
}
} catch (Throwable $e) {
// Do nothing.
}
$entry->type($type)->tags(Arr::collapse(array_map(function ($tagCallback) use ($entry) {
return $tagCallback($entry);
}, static::$tagUsing)));
static::withoutRecording(function () use ($entry) {
if (collect(static::$filterUsing)->every->__invoke($entry)) {
static::$entriesQueue[] = $entry;
}
if (static::$afterRecordingHook) {
call_user_func(static::$afterRecordingHook, new static, $entry);
}
});
}
/**
* Record the given entry update.
*
* @param \Laravel\Telescope\EntryUpdate $update
* @return void
*/
public static function recordUpdate(EntryUpdate $update)
{
if (static::$shouldRecord) {
static::$updatesQueue[] = $update;
}
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordBatch($entry)
{
static::record(EntryType::BATCH, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordCache(IncomingEntry $entry)
{
static::record(EntryType::CACHE, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordCommand(IncomingEntry $entry)
{
static::record(EntryType::COMMAND, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordDump(IncomingEntry $entry)
{
static::record(EntryType::DUMP, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordEvent(IncomingEntry $entry)
{
static::record(EntryType::EVENT, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordException(IncomingEntry $entry)
{
static::record(EntryType::EXCEPTION, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordGate(IncomingEntry $entry)
{
static::record(EntryType::GATE, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordJob($entry)
{
static::record(EntryType::JOB, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordLog(IncomingEntry $entry)
{
static::record(EntryType::LOG, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordMail(IncomingEntry $entry)
{
static::record(EntryType::MAIL, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordNotification($entry)
{
static::record(EntryType::NOTIFICATION, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordQuery(IncomingEntry $entry)
{
static::record(EntryType::QUERY, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordModelEvent(IncomingEntry $entry)
{
static::record(EntryType::MODEL, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordRedis(IncomingEntry $entry)
{
static::record(EntryType::REDIS, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordRequest(IncomingEntry $entry)
{
static::record(EntryType::REQUEST, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordScheduledCommand(IncomingEntry $entry)
{
static::record(EntryType::SCHEDULED_TASK, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordView(IncomingEntry $entry)
{
static::record(EntryType::VIEW, $entry);
}
/**
* Record the given entry.
*
* @param \Laravel\Telescope\IncomingEntry $entry
* @return void
*/
public static function recordClientRequest(IncomingEntry $entry)
{
static::record(EntryType::CLIENT_REQUEST, $entry);
}
/**
* Flush all entries in the queue.
*
* @return static
*/
public static function flushEntries()
{
static::$entriesQueue = [];
return new static;
}
/**
* Record the given exception.
*
* @param \Throwable|\Exception $e
* @param array $tags
* @return void
*/
public static function catch($e, $tags = [])
{
event(new MessageLogged('error', $e->getMessage(), [
'exception' => $e,
'telescope' => $tags,
]));
}
/**
* Set the callback that filters the entries that should be recorded.
*
* @param \Closure $callback
* @return static
*/
public static function filter(Closure $callback)
{
static::$filterUsing[] = $callback;
return new static;
}
/**
* Set the callback that filters the batches that should be recorded.
*
* @param \Closure $callback
* @return static
*/
public static function filterBatch(Closure $callback)
{
static::$filterBatchUsing[] = $callback;
return new static;
}
/**
* Set the callback that will be executed after an entry is recorded in the queue.
*
* @param \Closure $callback
* @return static
*/
public static function afterRecording(Closure $callback)
{
static::$afterRecordingHook = $callback;
return new static;
}
/**
* Add a callback that will be executed after an entry is stored.
*
* @param \Closure $callback
* @return static
*/
public static function afterStoring(Closure $callback)
{
static::$afterStoringHooks[] = $callback;
return new static;
}
/**
* Add a callback that adds tags to the record.
*
* @param \Closure $callback
* @return static
*/
public static function tag(Closure $callback)
{
static::$tagUsing[] = $callback;
return new static;
}
/**
* Store the queued entries and flush the queue.
*
* @param \Laravel\Telescope\Contracts\EntriesRepository $storage
* @return void
*/
public static function store(EntriesRepository $storage)
{
if (empty(static::$entriesQueue) && empty(static::$updatesQueue)) {
return;
}
static::withoutRecording(function () use ($storage) {
if (! collect(static::$filterBatchUsing)->every->__invoke(collect(static::$entriesQueue))) {
static::flushEntries();
}
try {
$batchId = Str::orderedUuid()->toString();
$storage->store(static::collectEntries($batchId));
$updateResult = $storage->update(static::collectUpdates($batchId)) ?: Collection::make();
if (! isset($_ENV['VAPOR_SSM_PATH'])) {
$updateResult->whenNotEmpty(fn ($pendingUpdates) => rescue(fn () => ProcessPendingUpdates::dispatch(
$pendingUpdates,
)->delay(now()->addSeconds(10))));
}
if ($storage instanceof TerminableRepository) {
$storage->terminate();
}
collect(static::$afterStoringHooks)->every->__invoke(static::$entriesQueue, $batchId);
} catch (Throwable $e) {
app(ExceptionHandler::class)->report($e);
}
});
static::$entriesQueue = [];
static::$updatesQueue = [];
}
/**
* Collect the entries for storage.
*
* @param string $batchId
* @return \Illuminate\Support\Collection
*/
protected static function collectEntries($batchId)
{
return collect(static::$entriesQueue)
->each(function ($entry) use ($batchId) {
$entry->batchId($batchId);
if ($entry->isDump()) {
$entry->assignEntryPointFromBatch(static::$entriesQueue);
}
});
}
/**
* Collect the updated entries for storage.
*
* @param string $batchId
* @return \Illuminate\Support\Collection
*/
protected static function collectUpdates($batchId)
{
return collect(static::$updatesQueue)
->each(function ($entry) use ($batchId) {
$entry->change(['updated_batch_id' => $batchId]);
});
}
/**
* Hide the given request header.
*
* @param array $headers
* @return static
*/
public static function hideRequestHeaders(array $headers)
{
static::$hiddenRequestHeaders = array_values(array_unique(array_merge(
static::$hiddenRequestHeaders,
$headers
)));
return new static;
}
/**
* Hide the given request parameters.
*
* @param array $attributes
* @return static
*/
public static function hideRequestParameters(array $attributes)
{
static::$hiddenRequestParameters = array_merge(
static::$hiddenRequestParameters,
$attributes
);
return new static;
}
/**
* Hide the given response parameters.
*
* @param array $attributes
* @return static
*/
public static function hideResponseParameters(array $attributes)
{
static::$hiddenResponseParameters = array_values(array_unique(array_merge(
static::$hiddenResponseParameters,
$attributes
)));
return new static;
}
/**
* Specifies that Telescope should record events fired by Laravel.
*
* @return static
*/
public static function recordFrameworkEvents()
{
static::$ignoreFrameworkEvents = false;
return new static;
}
/**
* Specifies that Telescope should use the dark theme.
*
* @return static
*/
public static function night()
{
static::$useDarkTheme = true;
return new static;
}
/**
* Register the Telescope user avatar callback.
*
* @param \Closure $callback
* @return static
*/
public static function avatar(Closure $callback)
{
Avatar::register($callback);
return new static;
}
/**
* Get the default JavaScript variables for Telescope.
*
* @return array
*/
public static function scriptVariables()
{
return [
'path' => config('telescope.path'),
'timezone' => config('app.timezone'),
'recording' => ! cache('telescope:pause-recording'),
];
}
/**
* Configure Telescope to not register its migrations.
*
* @return static
*/
public static function ignoreMigrations()
{
static::$runsMigrations = false;
return new static;
}
}