Returns an array of ReadableLogRecords retrieved when the recovery log was
opened.

@return ArrayList An array of ReadableLogRecords.
541781
ArrayList<ReadableLogRecord> recoveredRecords()
    {
        if (tc.isDebugEnabled())
            Tr.debug(tc, "recoveredRecords", _recoveredRecords);
        return _recoveredRecords;
    }
1217125
public function get()
    {
        $entries = [];

        $files = $this->getLogFiles();

        if (! is_array($files)) {
            throw new UnableToRetrieveLogFilesException('Unable to retrieve files from path: '.$this->getLogPath());
        }

        foreach ($files as $log) {
            /*
             * Set the current log path for easy manipulation
             * of the file if needed
             */
            $this->setCurrentLogPath($log['path']);

            /*
             * Parse the log into an array of entries, passing in the level
             * so it can be filtered
             */
            $parsedLog = $this->parseLog($log['contents'], $this->getEnvironment(), $this->getLevel());

            /*
             * Create a new LogEntry object for each parsed log entry
             */
            foreach ($parsedLog as $entry) {
                $newEntry = new LogEntry($this->parser, $this->cache, $entry);

                /*
                 * Check if the entry has already been read,
                 * and if read entries should be included.
                 *
                 * If includeRead is false, and the entry is read,
                 * then continue processing.
                 */
                if (!$this->includeRead && $newEntry->isRead()) {
                    continue;
                }

                $entries[$newEntry->id] = $newEntry;
            }
        }

        return $this->postCollectionModifiers(new Collection($entries));
    }
1168028
private function readRecord(): array
    {
        // Not enough data to read header
        if ($this->bufferLength < 8) {
            return [];
        }

        $headerData = substr($this->buffer, 0, 8);

        $headerFormat = 'Cversion/Ctype/nrequestId/ncontentLength/CpaddingLength/x';

        $record = unpack($headerFormat, $headerData);

        // Not enough data to read rest of record
        if ($this->bufferLength - 8 < $record['contentLength'] + $record['paddingLength']) {
            return [];
        }

        $record['contentData'] = substr($this->buffer, 8, $record['contentLength']);

        // Remove the record from the buffer
        $recordSize = 8 + $record['contentLength'] + $record['paddingLength'];

        $this->buffer        = substr($this->buffer, $recordSize);
        $this->bufferLength -= $recordSize;

        return $record;
    }
191080
public function recover()
    {
        return array_map(function ($value) {
            return $value instanceof Serialization ? $value->recover() : $value;
        }, $this->values);
    }
932083
public java.util.List<DescribeDBLogFilesDetails> getDescribeDBLogFiles() {
        if (describeDBLogFiles == null) {
            describeDBLogFiles = new com.amazonaws.internal.SdkInternalList<DescribeDBLogFilesDetails>();
        }
        return describeDBLogFiles;
    }
1098444
public function getLog()
    {
        if (null == $this->log_unserialized && null !== $this->log) {
            $this->log_unserialized = unserialize($this->log);
        }

        return $this->log_unserialized;
    }
1328506
public function getRecords()
    {
        $data = array();

        // List identifiers
        if (empty($this->metadataIterator)) {
            $this->metadataIterator = $this->endpoint->listMetadataFormats();
        } else {
            $this->metadataIterator->rewind(); // rewind the iterator
        }

        // Auto-determine a metadata prefix to use for getting records
        $mdPrefix = (string) $this->metadataIterator->current()->metadataPrefix;

        $data = array(
            'header' => array('Identifier', 'Title', 'usageDataResourceURL'),
            'rows' => array(),
        );

        // Iterate
        $recordIterator = $this->endpoint->listRecords($mdPrefix);
        for ($i = 0; $i < 10; $i++) {
            $rec = $recordIterator->next();
            $data['rows'][] = array(
                $rec->header->identifier,
                // Truncate title
                substr($rec->metadata->commParadata->paradataTitle->string->__toString(), 0, 30),
                $rec->metadata->commParadata->usageDataResourceURL
            );
        }

        return $data;
    }
210509
public function toRecords()
    {
        $result = [new Record(new Header(RecordType::beginRequest(), $this->getRequestId(), 8), \pack('xCCxxxxx', $this->role->value(), 0xFF & ($this->keepConnection ? 1 : 0)))];

        foreach ($this->getParameters()->encode($this->getRequestId()) as $value) {
            $result[] = $value;
        }

        while ($chunk = $this->stdin->read(65535)) {
            $result[] = new Record(new Header(RecordType::stdin(), $this->getRequestId(), strlen($chunk)), $chunk);
        }

        $result[] = new Record(new Header(RecordType::stdin(), $this->getRequestId(), 0, 0), '');

        return new ArrayIterator($result);
    }
480389
protected function getRecordings() {
        if (!$this->_recordings) {
            $this->_recordings = new RecordingList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['sid']
            );
        }

        return $this->_recordings;
    }
1016417
public static TreeSet<File> getLogFiles() {

        TreeSet<File> result = new TreeSet<>();
        for (File file : new File(CmsLogFileApp.LOG_FOLDER).listFiles()) {
            result.add(file);
        }
        for (String dir : getAdditionalLogDirectories()) {
            File file = new File(dir);
            if (file.exists()) {
                if (file.isDirectory()) {
                    for (File child : file.listFiles()) {
                        if (child.canRead()) {
                            result.add(child);
                        } else {
                            LOG.error("Can not read " + child.getAbsolutePath());
                        }
                    }
                }
            }
        }
        return result;
    }
858321
public function getRecordings()
    {
        $uri = 'recordings/stored';
        $response = $this->client->getEndpoint()->get($uri);

        $recordings = [];
        foreach (\GuzzleHttp\json_decode($response->getBody()) as $recording) {
            $recordings[] = new StoredRecording($recording);
        }

        return $recordings;
    }
973883
public LruList<LoggingEvent> getEvents() {
        if (events == null) {
            events = new LruList<LoggingEvent>(LoggingEvent.class, getSize());
        }
        return events;
    }
744311
public static function getDeleteTableLogTables()
    {
        $provider = StaticContainer::get('Piwik\Plugin\LogTablesProvider');

        $result = array();
        foreach ($provider->getAllLogTables() as $logTable) {

            if ($logTable->getColumnToJoinOnIdVisit()) {
                $result[] = Common::prefixTable($logTable->getName());
            }
        }

        if (Db::isLockPrivilegeGranted()) {
            $result[] = Common::prefixTable('log_action');
        }

        return $result;
    }
833069
@Override
	public List<IXADataRecorder> readIncompleteTransactions() {
		List<IXADataRecorder> messageSequences = new ArrayList<IXADataRecorder>();
		// recover all loggers ....
		try {
			
			IXARecorderRecovery recorderRecovery= new XARecorderRecovery(this.loggerFactory);

			Set<IXADataRecorder> xaDataRecorders = recorderRecovery.getRecoveredXADataRecorders();

			for (Iterator<IXADataRecorder> iterator = xaDataRecorders.iterator(); iterator.hasNext();) {
				IXADataRecorder dataRecorder = iterator.next();

				if (!dataRecorder.isEmpty()) {
					messageSequences.add(dataRecorder);
				} else {
					dataRecorder.destroy();
				}

			}
			return messageSequences;
		} catch (Exception e) {
			throw new DelegatedRuntimeException(e);
		}
	}
435917
public Iterable<ServerInstanceLogRecordList> getLogLists(Level minLevel,
			Level maxLevel) throws LogRepositoryException {
		logger.entering(thisClass, "getLogLists", new Object[]{minLevel, maxLevel});
		
		LogQueryBean query = new LogQueryBean();
		query.setLevels(minLevel, maxLevel);
		Iterable<ServerInstanceLogRecordList> result = getLogLists(null, query);
		
		logger.exiting(thisClass, "getLogLists", result);
		return result;
	}
141996
public function getLoggableEvents() {
		$list = [
			EVENT_CORE_USER_REGISTER,
			EVENT_CORE_BO_LOGIN_OK,
			EVENT_CORE_BO_LOGIN_FAIL,
			EVENT_CORE_LOG_CLEAR,
			//EVENT_CORE_DIR_CREATE,
			//EVENT_CORE_DIR_EDIT,
			//EVENT_CORE_DIR_DELETE,
			//EVENT_CORE_MATH_CREATE,
			//EVENT_CORE_MATH_EDIT,
			//EVENT_CORE_MATH_DELETE,
			//EVENT_CORE_MATH_PUB,
			//EVENT_CORE_MATH_UNPUB,
			//EVENT_CORE_USER_PROP,
		];
		
		return  array_diff(
			array_merge ( $list, (array)$this->configGet('events_log_enabled') ),
			(array)$this->configGet('events_log_disabled')
		);
	}
537250
public function readLog(): array
    {
        $logPath = $this->getLogPath();

        if (!file_exists($logPath)) {
            return [];
        }

        $data = @unserialize(file_get_contents($logPath));

        if (false === $data) {
            throw new \RuntimeException('Could not unserialize log file '.$logPath);
        }

        return (array) $data;
    }