_id stringlengths 2 7 | title stringlengths 3 151 | partition stringclasses 3
values | text stringlengths 83 13k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14000 | ExtractsMailableTags.registerMailableTagExtractor | train | protected static function registerMailableTagExtractor()
{
Mailable::buildViewDataUsing(function ($mailable) {
return [
'__telescope' => ExtractTags::from($mailable),
'__telescope_mailable' => get_class($mailable),
'__telescope_queued' => in_array(... | php | {
"resource": ""
} |
q14001 | QueryWatcher.recordQuery | train | public function recordQuery(QueryExecuted $event)
{
if (! Telescope::isRecording()) {
return;
}
$time = $event->time;
$caller = $this->getCallerFromStackTrace();
Telescope::recordQuery(IncomingEntry::make([
'connection' => $event->connectionName,
... | php | {
"resource": ""
} |
q14002 | RecordingController.toggle | train | public function toggle()
{
if ($this->cache->get('telescope:pause-recording')) {
$this->cache->forget('telescope:pause-recording');
} else {
$this->cache->put('telescope:pause-recording', true, now()->addDays(30));
}
} | php | {
"resource": ""
} |
q14003 | EventWatcher.recordEvent | train | public function recordEvent($eventName, $payload)
{
if (! Telescope::isRecording() || $this->shouldIgnore($eventName)) {
return;
}
$formattedPayload = $this->extractPayload($eventName, $payload);
Telescope::recordEvent(IncomingEntry::make([
'name' => $eventN... | php | {
"resource": ""
} |
q14004 | EventWatcher.extractPayload | train | protected function extractPayload($eventName, $payload)
{
if (class_exists($eventName) && isset($payload[0]) && is_object($payload[0])) {
return ExtractProperties::from($payload[0]);
}
return collect($payload)->map(function ($value) {
return is_object($value) ? [
... | php | {
"resource": ""
} |
q14005 | EventWatcher.formatListeners | train | protected function formatListeners($eventName)
{
return collect(app('events')->getListeners($eventName))
->map(function ($listener) {
$listener = (new ReflectionFunction($listener))
->getStaticVariables()['listener'];
if (is_string($listen... | php | {
"resource": ""
} |
q14006 | EventWatcher.formatClosureListener | train | protected function formatClosureListener(Closure $listener)
{
$listener = new ReflectionFunction($listener);
return sprintf('Closure at %s[%s:%s]',
$listener->getFileName(),
$listener->getStartLine(),
$listener->getEndLine()
);
} | php | {
"resource": ""
} |
q14007 | Telescope.start | train | public static function start($app)
{
if (! config('telescope.enabled')) {
return;
}
static::registerWatchers($app);
static::registerMailableTagExtractor();
if (static::runningApprovedArtisanCommand($app) ||
static::handlingApprovedRequest($app)
... | php | {
"resource": ""
} |
q14008 | Telescope.runningApprovedArtisanCommand | train | protected static function runningApprovedArtisanCommand($app)
{
return $app->runningInConsole() && ! in_array(
$_SERVER['argv'][1] ?? null,
array_merge([
// 'migrate',
'migrate:rollback',
'migrate:fresh',
// 'migrate:ref... | php | {
"resource": ""
} |
q14009 | Telescope.withoutRecording | train | public static function withoutRecording($callback)
{
$shouldRecord = static::$shouldRecord;
static::$shouldRecord = false;
call_user_func($callback);
static::$shouldRecord = $shouldRecord;
} | php | {
"resource": ""
} |
q14010 | Telescope.record | train | protected static function record(string $type, IncomingEntry $entry)
{
if (! static::isRecording()) {
return;
}
$entry->type($type)->tags(
static::$tagUsing ? call_user_func(static::$tagUsing, $entry) : []
);
try {
if (Auth::hasUser()) {
... | php | {
"resource": ""
} |
q14011 | Telescope.catch | train | public static function catch($e, $tags = [])
{
if ($e instanceof Throwable && ! $e instanceof Exception) {
$e = new FatalThrowableError($e);
}
event(new MessageLogged('error', $e->getMessage(), [
'exception' => $e,
'telescope' => $tags,
]));
} | php | {
"resource": ""
} |
q14012 | Telescope.store | train | public static function store(EntriesRepository $storage)
{
if (empty(static::$entriesQueue) && empty(static::$updatesQueue)) {
return;
}
if (! collect(static::$filterBatchUsing)->every->__invoke(collect(static::$entriesQueue))) {
static::flushEntries();
}
... | php | {
"resource": ""
} |
q14013 | Telescope.collectEntries | train | protected static function collectEntries($batchId)
{
return collect(static::$entriesQueue)
->each(function ($entry) use ($batchId) {
$entry->batchId($batchId);
if ($entry->isDump()) {
$entry->assignEntryPointFromBatch(static::$entriesQueue);
... | php | {
"resource": ""
} |
q14014 | Telescope.collectUpdates | train | protected static function collectUpdates($batchId)
{
return collect(static::$updatesQueue)
->each(function ($entry) use ($batchId) {
$entry->change(['updated_batch_id' => $batchId]);
});
} | php | {
"resource": ""
} |
q14015 | TelescopeServiceProvider.registerStorageDriver | train | protected function registerStorageDriver()
{
$driver = config('telescope.driver');
if (method_exists($this, $method = 'register'.ucfirst($driver).'Driver')) {
$this->$method();
}
} | php | {
"resource": ""
} |
q14016 | TelescopeServiceProvider.registerDatabaseDriver | train | protected function registerDatabaseDriver()
{
$this->app->singleton(
EntriesRepository::class, DatabaseEntriesRepository::class
);
$this->app->singleton(
ClearableRepository::class, DatabaseEntriesRepository::class
);
$this->app->singleton(
... | php | {
"resource": ""
} |
q14017 | EntryController.status | train | protected function status()
{
if (! config('telescope.enabled', false)) {
return 'disabled';
}
if (cache('telescope:pause-recording', false)) {
return 'paused';
}
$watcher = config('telescope.watchers.'.$this->watcher());
if (! $watcher || (... | php | {
"resource": ""
} |
q14018 | ExceptionWatcher.recordException | train | public function recordException(MessageLogged $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
$exception = $event->context['exception'];
Telescope::recordException(
IncomingExceptionEntry::make($exception, [
... | php | {
"resource": ""
} |
q14019 | JobWatcher.recordJob | train | public function recordJob($connection, $queue, array $payload)
{
if (! Telescope::isRecording()) {
return;
}
$content = array_merge([
'status' => 'pending',
], $this->defaultJobData($connection, $queue, $payload, $this->data($payload)));
Telescope::r... | php | {
"resource": ""
} |
q14020 | JobWatcher.recordProcessedJob | train | public function recordProcessedJob(JobProcessed $event)
{
if (! Telescope::isRecording()) {
return;
}
$uuid = $event->job->payload()['telescope_uuid'] ?? null;
if (! $uuid) {
return;
}
Telescope::recordUpdate(EntryUpdate::make(
$... | php | {
"resource": ""
} |
q14021 | JobWatcher.recordFailedJob | train | public function recordFailedJob(JobFailed $event)
{
if (! Telescope::isRecording()) {
return;
}
$uuid = $event->job->payload()['telescope_uuid'] ?? null;
if (! $uuid) {
return;
}
Telescope::recordUpdate(EntryUpdate::make(
$uuid, ... | php | {
"resource": ""
} |
q14022 | JobWatcher.defaultJobData | train | protected function defaultJobData($connection, $queue, array $payload, array $data)
{
return [
'connection' => $connection,
'queue' => $queue,
'name' => $payload['displayName'],
'tries' => $payload['maxTries'],
'timeout' => $payload['timeout'],
... | php | {
"resource": ""
} |
q14023 | TelescopeApplicationServiceProvider.authorization | train | protected function authorization()
{
$this->gate();
Telescope::auth(function ($request) {
return app()->environment('local') ||
Gate::check('viewTelescope', [$request->user()]);
});
} | php | {
"resource": ""
} |
q14024 | EntryUpdate.addTags | train | public function addTags(array $tags)
{
$this->tagsChanges['added'] = array_unique(
array_merge($this->tagsChanges['added'], $tags)
);
return $this;
} | php | {
"resource": ""
} |
q14025 | EntryUpdate.removeTags | train | public function removeTags(array $tags)
{
$this->tagsChanges['removed'] = array_unique(
array_merge($this->tagsChanges['removed'], $tags)
);
return $this;
} | php | {
"resource": ""
} |
q14026 | RedisWatcher.recordCommand | train | public function recordCommand(CommandExecuted $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordRedis(IncomingEntry::make([
'connection' => $event->connectionName,
'command' => $this->formatCommand($even... | php | {
"resource": ""
} |
q14027 | RedisWatcher.formatCommand | train | private function formatCommand($command, $parameters)
{
$parameters = collect($parameters)->map(function ($parameter) {
if (is_array($parameter)) {
return collect($parameter)->map(function ($value, $key) {
return is_int($key) ? $value : "{$key} {$value}";
... | php | {
"resource": ""
} |
q14028 | ExtractTags.from | train | public static function from($target)
{
if ($tags = static::explicitTags([$target])) {
return $tags;
}
return static::modelsFor([$target])->map(function ($model) {
return FormatModel::given($model);
})->all();
} | php | {
"resource": ""
} |
q14029 | ExtractTags.fromArray | train | public static function fromArray(array $data)
{
$models = collect($data)->map(function ($value) {
if ($value instanceof Model) {
return [$value];
} elseif ($value instanceof EloquentCollection) {
return $value->flatten();
}
})->coll... | php | {
"resource": ""
} |
q14030 | ExtractTags.tagsForListener | train | protected static function tagsForListener($job)
{
return collect(
[static::extractListener($job), static::extractEvent($job),
])->map(function ($job) {
return static::from($job);
})->collapse()->unique()->toArray();
} | php | {
"resource": ""
} |
q14031 | ExtractTags.targetsFor | train | protected static function targetsFor($job)
{
switch (true) {
case $job instanceof BroadcastEvent:
return [$job->event];
case $job instanceof CallQueuedListener:
return [static::extractEvent($job)];
case $job instanceof SendQueuedMailable:
... | php | {
"resource": ""
} |
q14032 | ExtractTags.modelsFor | train | protected static function modelsFor(array $targets)
{
$models = [];
foreach ($targets as $target) {
$models[] = collect((new ReflectionClass($target))->getProperties())->map(function ($property) use ($target) {
$property->setAccessible(true);
$value = $p... | php | {
"resource": ""
} |
q14033 | ExtractTags.extractEvent | train | protected static function extractEvent($job)
{
return isset($job->data[0]) && is_object($job->data[0])
? $job->data[0]
: new stdClass;
} | php | {
"resource": ""
} |
q14034 | ExtractProperties.from | train | public static function from($target)
{
return collect((new ReflectionClass($target))->getProperties())
->mapWithKeys(function ($property) use ($target) {
$property->setAccessible(true);
if (($value = $property->getValue($target)) instanceof Model) {
... | php | {
"resource": ""
} |
q14035 | EntryModel.scopeWithTelescopeOptions | train | public function scopeWithTelescopeOptions($query, $type, EntryQueryOptions $options)
{
$this->whereType($query, $type)
->whereBatchId($query, $options)
->whereTag($query, $options)
->whereFamilyHash($query, $options)
->whereBeforeSequence($quer... | php | {
"resource": ""
} |
q14036 | EntryModel.whereBatchId | train | protected function whereBatchId($query, EntryQueryOptions $options)
{
$query->when($options->batchId, function ($query, $batchId) {
return $query->where('batch_id', $batchId);
});
return $this;
} | php | {
"resource": ""
} |
q14037 | EntryModel.whereBeforeSequence | train | protected function whereBeforeSequence($query, EntryQueryOptions $options)
{
$query->when($options->beforeSequence, function ($query, $beforeSequence) {
return $query->where('sequence', '<', $beforeSequence);
});
return $this;
} | php | {
"resource": ""
} |
q14038 | EntryModel.filter | train | protected function filter($query, EntryQueryOptions $options)
{
if ($options->familyHash || $options->tag || $options->batchId) {
return $this;
}
$query->where('should_display_on_index', true);
return $this;
} | php | {
"resource": ""
} |
q14039 | InstallCommand.registerTelescopeServiceProvider | train | protected function registerTelescopeServiceProvider()
{
$namespace = str_replace_last('\\', '', $this->getAppNamespace());
$appConfig = file_get_contents(config_path('app.php'));
if (Str::contains($appConfig, $namespace.'\\Providers\\TelescopeServiceProvider::class')) {
return;... | php | {
"resource": ""
} |
q14040 | DatabaseEntriesRepository.find | train | public function find($id): EntryResult
{
$entry = EntryModel::on($this->connection)->whereUuid($id)->firstOrFail();
$tags = $this->table('telescope_entries_tags')
->where('entry_uuid', $id)
->pluck('tag')
->all();
retu... | php | {
"resource": ""
} |
q14041 | DatabaseEntriesRepository.get | train | public function get($type, EntryQueryOptions $options)
{
return EntryModel::on($this->connection)
->withTelescopeOptions($type, $options)
->take($options->limit)
->orderByDesc('sequence')
->get()->reject(function ($entry) {
return ! is_array($e... | php | {
"resource": ""
} |
q14042 | DatabaseEntriesRepository.store | train | public function store(Collection $entries)
{
if ($entries->isEmpty()) {
return;
}
[$exceptions, $entries] = $entries->partition->isException();
$this->storeExceptions($exceptions);
$table = $this->table('telescope_entries');
$entries->chunk($this->chun... | php | {
"resource": ""
} |
q14043 | DatabaseEntriesRepository.storeExceptions | train | protected function storeExceptions(Collection $exceptions)
{
$this->table('telescope_entries')->insert($exceptions->map(function ($exception) {
$occurrences = $this->table('telescope_entries')
->where('type', EntryType::EXCEPTION)
->where('family_hash', $e... | php | {
"resource": ""
} |
q14044 | DatabaseEntriesRepository.storeTags | train | protected function storeTags($results)
{
$this->table('telescope_entries_tags')->insert($results->flatMap(function ($tags, $uuid) {
return collect($tags)->map(function ($tag) use ($uuid) {
return [
'entry_uuid' => $uuid,
'tag' => $tag,
... | php | {
"resource": ""
} |
q14045 | DatabaseEntriesRepository.update | train | public function update(Collection $updates)
{
foreach ($updates as $update) {
$entry = $this->table('telescope_entries')
->where('uuid', $update->uuid)
->where('type', $update->type)
->first();
if (!... | php | {
"resource": ""
} |
q14046 | DatabaseEntriesRepository.updateTags | train | protected function updateTags($entry)
{
if (! empty($entry->tagsChanges['added'])) {
$this->table('telescope_entries_tags')->insert(
collect($entry->tagsChanges['added'])->map(function ($tag) use ($entry) {
return [
'entry_uuid' => $ent... | php | {
"resource": ""
} |
q14047 | DatabaseEntriesRepository.isMonitoring | train | public function isMonitoring(array $tags)
{
if (is_null($this->monitoredTags)) {
$this->loadMonitoredTags();
}
return count(array_intersect($tags, $this->monitoredTags)) > 0;
} | php | {
"resource": ""
} |
q14048 | DatabaseEntriesRepository.monitor | train | public function monitor(array $tags)
{
$tags = array_diff($tags, $this->monitoring());
if (empty($tags)) {
return;
}
$this->table('telescope_monitoring')
->insert(collect($tags)
->mapWithKeys(function ($tag) {
... | php | {
"resource": ""
} |
q14049 | RegistersWatchers.registerWatchers | train | protected static function registerWatchers($app)
{
foreach (config('telescope.watchers') as $key => $watcher) {
if (is_string($key) && $watcher === false) {
continue;
}
if (is_array($watcher) && ! ($watcher['enabled'] ?? true)) {
continue;... | php | {
"resource": ""
} |
q14050 | IncomingExceptionEntry.isReportableException | train | public function isReportableException()
{
$handler = app(ExceptionHandler::class);
return method_exists($handler, 'shouldReport')
? $handler->shouldReport($this->exception) : true;
} | php | {
"resource": ""
} |
q14051 | GateWatcher.recordGateCheck | train | public function recordGateCheck(?Authenticatable $user, $ability, $result, $arguments)
{
if (! Telescope::isRecording() || $this->shouldIgnore($ability)) {
return;
}
$caller = $this->getCallerFromStackTrace();
Telescope::recordGate(IncomingEntry::make([
'abi... | php | {
"resource": ""
} |
q14052 | GateWatcher.formatArguments | train | private function formatArguments($arguments)
{
return collect($arguments)->map(function ($argument) {
return $argument instanceof Model ? FormatModel::given($argument) : $argument;
})->toArray();
} | php | {
"resource": ""
} |
q14053 | MailWatcher.recordMail | train | public function recordMail(MessageSent $event)
{
if (! Telescope::isRecording()) {
return;
}
Telescope::recordMail(IncomingEntry::make([
'mailable' => $this->getMailable($event),
'queued' => $this->getQueuedStatus($event),
'from' => $event->me... | php | {
"resource": ""
} |
q14054 | MailWatcher.getQueuedStatus | train | protected function getQueuedStatus($event)
{
if (isset($event->data['__laravel_notification_queued'])) {
return $event->data['__laravel_notification_queued'];
}
return $event->data['__telescope_queued'] ?? false;
} | php | {
"resource": ""
} |
q14055 | MailWatcher.tags | train | private function tags($message, $data)
{
return array_merge(
array_keys($message->getTo() ?: []),
array_keys($message->getCc() ?: []),
array_keys($message->getBcc() ?: []),
$data['__telescope'] ?? []
);
} | php | {
"resource": ""
} |
q14056 | MailEmlController.show | train | public function show(EntriesRepository $storage, $id)
{
return response($storage->find($id)->content['raw'], 200, [
'Content-Type' => 'message/rfc822',
'Content-Disposition' => 'attachment; filename="mail-'.$id.'.eml"',
]);
} | php | {
"resource": ""
} |
q14057 | ModelWatcher.recordAction | train | public function recordAction($event, $data)
{
if (! Telescope::isRecording() || ! $this->shouldRecord($event)) {
return;
}
$model = FormatModel::given($data[0]);
$changes = $data[0]->getChanges();
Telescope::recordModelEvent(IncomingEntry::make(array_filter([
... | php | {
"resource": ""
} |
q14058 | ScheduleWatcher.recordCommand | train | public function recordCommand(CommandStarting $event)
{
if (! Telescope::isRecording() ||
$event->command !== 'schedule:run' &&
$event->command !== 'schedule:finish') {
return;
}
collect(app(Schedule::class)->events())->each(function ($event) {
... | php | {
"resource": ""
} |
q14059 | ScheduleWatcher.getEventOutput | train | protected function getEventOutput(Event $event)
{
if (! $event->output ||
$event->output === $event->getDefaultOutput() ||
$event->shouldAppendOutput ||
! file_exists($event->output)) {
return '';
}
return trim(file_get_contents($event->output... | php | {
"resource": ""
} |
q14060 | ListensForStorageOpportunities.storeEntriesAfterWorkerLoop | train | protected static function storeEntriesAfterWorkerLoop($app)
{
$app['events']->listen(JobProcessing::class, function () {
static::startRecording();
static::$processingJobs[] = true;
});
$app['events']->listen(JobProcessed::class, function ($event) use ($app) {
... | php | {
"resource": ""
} |
q14061 | ListensForStorageOpportunities.storeIfDoneProcessingJob | train | protected static function storeIfDoneProcessingJob($event, $app)
{
array_pop(static::$processingJobs);
if (empty(static::$processingJobs)) {
static::store($app[EntriesRepository::class]);
if ($event->connectionName !== 'sync') {
static::stopRecording();
... | php | {
"resource": ""
} |
q14062 | NotificationWatcher.recordNotification | train | public function recordNotification(NotificationSent $event)
{
if (! Telescope::isRecording()) {
return;
}
Telescope::recordNotification(IncomingEntry::make([
'notification' => get_class($event->notification),
'queued' => in_array(ShouldQueue::class, class... | php | {
"resource": ""
} |
q14063 | NotificationWatcher.tags | train | private function tags($event)
{
return array_merge([
$this->formatNotifiable($event->notifiable),
], ExtractTags::from($event->notification));
} | php | {
"resource": ""
} |
q14064 | NotificationWatcher.formatNotifiable | train | private function formatNotifiable($notifiable)
{
if ($notifiable instanceof Model) {
return FormatModel::given($notifiable);
} elseif ($notifiable instanceof AnonymousNotifiable) {
return 'Anonymous:'.implode(',', $notifiable->routes);
}
return get_class($not... | php | {
"resource": ""
} |
q14065 | ExceptionContext.get | train | public static function get(Throwable $exception)
{
return collect(explode("\n", file_get_contents($exception->getFile())))
->slice($exception->getLine() - 10, 20)
->mapWithKeys(function ($value, $key) {
return [$key + 1 => $value];
})->all();
} | php | {
"resource": ""
} |
q14066 | LogWatcher.recordLog | train | public function recordLog(MessageLogged $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordLog(
IncomingEntry::make([
'level' => $event->level,
'message' => $event->message,
... | php | {
"resource": ""
} |
q14067 | EntryQueryOptions.fromRequest | train | public static function fromRequest(Request $request)
{
return (new static)
->batchId($request->batch_id)
->uuids($request->uuids)
->beforeSequence($request->before)
->tag($request->tag)
->familyHash($request->family_hash)
... | php | {
"resource": ""
} |
q14068 | RequestWatcher.recordRequest | train | public function recordRequest(RequestHandled $event)
{
if (! Telescope::isRecording()) {
return;
}
Telescope::recordRequest(IncomingEntry::make([
'uri' => str_replace($event->request->root(), '', $event->request->fullUrl()) ?: '/',
'method' => $event->req... | php | {
"resource": ""
} |
q14069 | RequestWatcher.headers | train | protected function headers($headers)
{
$headers = collect($headers)->map(function ($header) {
return $header[0];
})->toArray();
return $this->hideParameters($headers,
Telescope::$hiddenRequestHeaders
);
} | php | {
"resource": ""
} |
q14070 | RequestWatcher.hideParameters | train | protected function hideParameters($data, $hidden)
{
foreach ($hidden as $parameter) {
if (Arr::get($data, $parameter)) {
Arr::set($data, $parameter, '********');
}
}
return $data;
} | php | {
"resource": ""
} |
q14071 | RequestWatcher.input | train | private function input(Request $request)
{
$files = $request->files->all();
array_walk_recursive($files, function (&$file) {
$file = [
'name' => $file->getClientOriginalName(),
'size' => $file->isFile() ? ($file->getSize() / 1000).'KB' : '0',
... | php | {
"resource": ""
} |
q14072 | RequestWatcher.response | train | protected function response(Response $response)
{
$content = $response->getContent();
if (is_string($content) &&
is_array(json_decode($content, true)) &&
json_last_error() === JSON_ERROR_NONE) {
return $this->contentWithinLimits($content)
? $t... | php | {
"resource": ""
} |
q14073 | RequestWatcher.extractDataFromView | train | protected function extractDataFromView($view)
{
return collect($view->getData())->map(function ($value) {
if ($value instanceof Model) {
return FormatModel::given($value);
} elseif (is_object($value)) {
return [
'class' => get_class... | php | {
"resource": ""
} |
q14074 | CommandWatcher.recordCommand | train | public function recordCommand(CommandFinished $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCommand(IncomingEntry::make([
'command' => $event->command ?? $event->input->getArguments()['command'] ?? 'default',
... | php | {
"resource": ""
} |
q14075 | CacheWatcher.recordCacheHit | train | public function recordCacheHit(CacheHit $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCache(IncomingEntry::make([
'type' => 'hit',
'key' => $event->key,
'value' => $event->value,
... | php | {
"resource": ""
} |
q14076 | CacheWatcher.recordCacheMissed | train | public function recordCacheMissed(CacheMissed $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCache(IncomingEntry::make([
'type' => 'missed',
'key' => $event->key,
]));
} | php | {
"resource": ""
} |
q14077 | CacheWatcher.recordKeyWritten | train | public function recordKeyWritten(KeyWritten $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCache(IncomingEntry::make([
'type' => 'set',
'key' => $event->key,
'value' => $event->value,
... | php | {
"resource": ""
} |
q14078 | IncomingEntry.user | train | public function user($user)
{
$this->user = $user;
$this->content = array_merge($this->content, [
'user' => [
'id' => $user->getAuthIdentifier(),
'name' => $user->name ?? null,
'email' => $user->email ?? null,
],
]);
... | php | {
"resource": ""
} |
q14079 | IncomingEntry.tags | train | public function tags(array $tags)
{
$this->tags = array_unique(array_merge($this->tags, $tags));
return $this;
} | php | {
"resource": ""
} |
q14080 | IncomingEntry.hasMonitoredTag | train | public function hasMonitoredTag()
{
if (! empty($this->tags)) {
return app(EntriesRepository::class)->isMonitoring($this->tags);
}
return false;
} | php | {
"resource": ""
} |
q14081 | IncomingEntry.toArray | train | public function toArray()
{
return [
'uuid' => $this->uuid,
'batch_id' => $this->batchId,
'type' => $this->type,
'content' => $this->content,
'created_at' => $this->recordedAt->toDateTimeString(),
];
} | php | {
"resource": ""
} |
q14082 | IncomingDumpEntry.assignEntryPointFromBatch | train | public function assignEntryPointFromBatch(array $batch)
{
$entryPoint = collect($batch)->first(function ($entry) {
return in_array($entry->type, [EntryType::REQUEST, EntryType::JOB, EntryType::COMMAND]);
});
if (! $entryPoint) {
return;
}
$this->cont... | php | {
"resource": ""
} |
q14083 | IncomingDumpEntry.entryPointDescription | train | private function entryPointDescription($entryPoint)
{
switch ($entryPoint->type) {
case EntryType::REQUEST:
return $entryPoint->content['method'].' '.$entryPoint->content['uri'];
case EntryType::JOB:
return $entryPoint->content['name'];
c... | php | {
"resource": ""
} |
q14084 | EntryResult.jsonSerialize | train | public function jsonSerialize()
{
return [
'id' => $this->id,
'sequence' => $this->sequence,
'batch_id' => $this->batchId,
'type' => $this->type,
'content' => $this->content,
'tags' => $this->tags,
'family_hash' => $this->fa... | php | {
"resource": ""
} |
q14085 | GitInfoCollector.collect | train | public function collect() : GitInfo
{
$branch = $this->collectBranch();
$commit = $this->collectCommit();
$remotes = $this->collectRemotes();
return new GitInfo($branch, $commit, $remotes);
} | php | {
"resource": ""
} |
q14086 | Message.parse | train | public static function parse(string $msg): Message
{
$obj = new self;
$parts = explode("\r\n", $msg);
$obj->body = MessageBody::parse(array_pop($parts));
foreach ($parts as $line) {
if ($line) {
$pair = explode(': ', $line);
$obj->headers[$... | php | {
"resource": ""
} |
q14087 | SimpleNameResolver.resolveName | train | protected function resolveName(Name $name, $type) {
$resolvedName = $this->nameContext->getResolvedName($name, $type);
if (null !== $resolvedName) {
$name->setAttribute('resolvedName', $resolvedName->toString());
}
return $name;
} | php | {
"resource": ""
} |
q14088 | Pool.streamForParent | train | private static function streamForParent(array $sockets)
{
list($for_read, $for_write) = $sockets;
// The parent will not use the write channel, so it
// must be closed to prevent deadlock.
fclose($for_write);
// stream_select will be used to read multiple streams, so these
... | php | {
"resource": ""
} |
q14089 | Pool.readResultsFromChildren | train | private function readResultsFromChildren()
{
// Create an array of all active streams, indexed by
// resource id.
$streams = [];
foreach ($this->read_streams as $stream) {
$streams[intval($stream)] = $stream;
}
// Create an array for the content received ... | php | {
"resource": ""
} |
q14090 | Pool.wait | train | public function wait(): array
{
// Read all the streams from child processes into an array.
$content = $this->readResultsFromChildren();
// Wait for all children to return
foreach ($this->child_pid_list as $child_pid) {
$process_lookup = posix_kill($child_pid, 0);
... | php | {
"resource": ""
} |
q14091 | CustomTraverser.traverseNode | train | protected function traverseNode(Node $node) : Node
{
foreach ($node->getSubNodeNames() as $name) {
$subNode =& $node->$name;
if (\is_array($subNode)) {
$subNode = $this->traverseArray($subNode);
if ($this->stopTraversal) {
break;
... | php | {
"resource": ""
} |
q14092 | ClassLikeAnalyzer.getFQCLNFromNameObject | train | public static function getFQCLNFromNameObject(
PhpParser\Node\Name $class_name,
Aliases $aliases
) {
/** @var string|null */
$resolved_name = $class_name->getAttribute('resolvedName');
if ($resolved_name) {
return $resolved_name;
}
if ($class_nam... | php | {
"resource": ""
} |
q14093 | ClassLikeAnalyzer.getTypeFromValue | train | public static function getTypeFromValue($value)
{
switch (gettype($value)) {
case 'boolean':
if ($value) {
return Type::getTrue();
}
return Type::getFalse();
case 'integer':
return Type::getInt(fals... | php | {
"resource": ""
} |
q14094 | EchoChecker.afterStatementAnalysis | train | public static function afterStatementAnalysis(
PhpParser\Node\Stmt $stmt,
Context $context,
StatementsSource $statements_source,
Codebase $codebase,
array &$file_replacements = []
) {
if ($stmt instanceof PhpParser\Node\Stmt\Echo_) {
foreach ($stmt->exprs ... | php | {
"resource": ""
} |
q14095 | Scanner.fileExistsForClassLike | train | private function fileExistsForClassLike(ClassLikes $classlikes, $fq_class_name)
{
$fq_class_name_lc = strtolower($fq_class_name);
if (isset($this->classlike_files[$fq_class_name_lc])) {
return true;
}
if ($fq_class_name === 'self') {
return false;
}
... | php | {
"resource": ""
} |
q14096 | TypeAnalyzer.isContainedByInPhp | train | public static function isContainedByInPhp(
Type\Union $input_type = null,
Type\Union $container_type
) {
if (!$input_type) {
return false;
}
if ($input_type->getId() === $container_type->getId()) {
return true;
}
if ($input_type->isNu... | php | {
"resource": ""
} |
q14097 | TypeAnalyzer.isSimplyContainedBy | train | public static function isSimplyContainedBy(
Type\Union $input_type,
Type\Union $container_type
) {
if ($input_type->getId() === $container_type->getId()) {
return true;
}
if ($input_type->isNullable() && !$container_type->isNullable()) {
return false;... | php | {
"resource": ""
} |
q14098 | BuildInfoCollector.fillJenkins | train | protected function fillJenkins() : self
{
if (isset($this->env['JENKINS_URL']) && isset($this->env['BUILD_NUMBER'])) {
$this->readEnv['CI_BUILD_NUMBER'] = $this->env['BUILD_NUMBER'];
$this->readEnv['CI_BUILD_URL'] = $this->env['JENKINS_URL'];
$this->env['CI_NAME'] = 'jenk... | php | {
"resource": ""
} |
q14099 | BuildInfoCollector.fillScrutinizer | train | protected function fillScrutinizer() : self
{
if (isset($this->env['SCRUTINIZER']) && $this->env['SCRUTINIZER']) {
$this->readEnv['CI_JOB_ID'] = $this->env['SCRUTINIZER_INSPECTION_UUID'];
$this->readEnv['CI_BRANCH'] = $this->env['SCRUTINIZER_BRANCH'];
$this->readEnv['CI_P... | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.