logGroups
@return void
323952
public function logGroups() {
        foreach($this->getGroupTotals() as $description => $total) {
            $time = number_format(round($total, 3), 3, '.', '');
            $this->getLogger()->info($description . ': ' . $time);
        }
        $this->resetGroups();
    }
881550
public function log($messages)
    {
        if (!is_array($messages)) {
            $messages = [$messages];
        }
        foreach ($messages as $message) {
            file_put_contents($this->logFile, date('d.m.Y H:i:s') . ' - ' . $message . PHP_EOL, FILE_APPEND | LOCK_EX);
        }
    }
672167
function ReportMemberGroupAction(Membergroup $memberGroup, Enums\Action $action)
    {
        $logItem = $this->CreateLogItem(Enums\ObjectType::MemberGroup(), $action);       
        if (!$action->Equals(Enums\Action::Delete()))
        {
            $logMemberGroup = new LogMembergroup();
            $logMemberGroup->SetLogItem($logItem);
            $logMemberGroup->SetMemberGroup($memberGroup);
            $logMemberGroup->Save();
        }
    }
1067638
private function startLogging()
    {
        $this->loggingStart = round(microtime(true) * 1000);
        $this->lastLog = $this->loggingStart;
    }
314942
private function _groupErrors( $date_time = 0 )
	{
		$error_log_path =  ROOT_PATH . '/logs/errors.log';
		$error_lines = file( $error_log_path, FILE_SKIP_EMPTY_LINES);
		if ( is_array( $error_lines ) ) {
			foreach ( $error_lines as $line )
			{
				if ( preg_match( "", $line , $matchs ) )
				{
					$last_date = $matchs[1];
					// Verify if the date is gt date_time.
					if ( strtotime( $last_date ) > $date_time )
					{
						$last_error = $matchs[2];
						if ( isset( $this->_parsed_errors[$last_error] ) )
						{
							$this->_parsed_errors[$last_error]['count']++;
							$this->_parsed_errors[$last_error]['finish_date'] = $last_date;
						}
						else
						{
							$this->_parsed_errors[$last_error]['count'] = 1;
							$this->_parsed_errors[$last_error]['init_date'] = $last_date;
							$this->_parsed_errors[$last_error]['finish_date'] = $last_date;
						}
					}
				}
			}
		}
		$this->_sortErrorsArray();
		unset( $error_lines );

	}
1325497
public void setLogGroups(java.util.Collection<LogGroup> logGroups) {
        if (logGroups == null) {
            this.logGroups = null;
            return;
        }

        this.logGroups = new com.amazonaws.internal.SdkInternalList<LogGroup>(logGroups);
    }
353525
private function clearEmptyGroups()
    {
        foreach (Craft::$app->fields->getAllGroups() as $group) {
            if (count($group->getFields()) == 0) {
                Craft::$app->fields->deleteGroup($group);
            }
        }
    }
805281
public function log(array $log)
    {
        $log['db'] = $this->database->getName();
        $log['collection'] = $this->getName();
        call_user_func($this->loggerCallable, $log);
    }
946371
public function extract() {
        foreach ($this->log as $line) {
            foreach ($this->messageGroupsJoined as $header => $keywords) {
                $pattern = $this->getPattern($keywords);

                if (preg_match($pattern, $line)) {
                    $this->appendToGroup($header, $line, $pattern);
                }
            }
        }

        // Remove empty groups
        foreach (array_keys($this->messageGroups) as $groupKey) {
            if (true === empty($this->groups[$groupKey])) {
                unset($this->messageGroups[$groupKey]);
            }
        }

        // The array_merge sorts $messageGroups basing on $groups
        return array_merge($this->messageGroups, $this->groups);
    }
793622
private function buildGroups()
    {
        $this->groups = [];
        $allGroups = $this->initialData[self::GROUPS] ?? [];
        foreach ($allGroups as $action => $groups) {
            \arsort($groups);
            $this->groups[$action] = \array_keys($groups);
        }
    }
104122
public void setLoggers(java.util.Collection<Logger> loggers) {
        if (loggers == null) {
            this.loggers = null;
            return;
        }

        this.loggers = new java.util.ArrayList<Logger>(loggers);
    }
80595
public function logEvents(array $auditLogs)
    {
        $PersisterTable = $this->getTable();

        $serializeFields = $this->getConfig('serializeFields');
        $primaryKeyExtractionStrategy = $this->getConfig('primaryKeyExtractionStrategy');
        $extractMetaFields = $this->getConfig('extractMetaFields');
        $unsetExtractedMetaFields = $this->getConfig('unsetExtractedMetaFields');
        $logErrors = $this->getConfig('logErrors');

        foreach ($auditLogs as $log) {
            $fields = $this->extractBasicFields($log, $serializeFields);
            $fields += $this->extractPrimaryKeyFields($log, $primaryKeyExtractionStrategy);
            $fields += $this->extractMetaFields(
                $log, $extractMetaFields, $unsetExtractedMetaFields, $serializeFields
            );

            $persisterEntity = $PersisterTable->newEntity($fields);

            if (!$PersisterTable->save($persisterEntity) &&
                $logErrors
            ) {
                $this->log($this->toErrorLog($persisterEntity));
            }
        }
    }
1054438
protected function setLoggers()
    {
        if ($loggers = $this->hasLoggerConfig()) {
            foreach ($loggers as $channel => $logger) {
                $loggerChannel = $this->getChannelName($logger, $channel);
                $loggerName = $this->getLoggerIdentified($logger, $loggerChannel);
                
                $this->container[$loggerName] = Logger::get(
                    $loggerChannel, 
                    $this->buildHandlers($logger['handlers']??[])
                );
            }
        }
    }
751743
private function generateGroups()
    {
        foreach ($this->app['config']->get('contenttypes') as $ctname => $ctype) {
            $keyprefix = 'contenttypes.' . $this->slugifyKey($ctname) . '.group.';

            if (isset($ctype['groups']) && is_array($ctype['groups'])) {
                foreach ($ctype['groups'] as $groupname) {
                    $key = $keyprefix . $this->slugifyKey($groupname);

                    if ($this->isSaved($key)) {
                        $this->translation[$key] = $this->saved[$key];
                    } else {
                        $fallback = $this->fallback($key);
                        $this->hints[$key] = ($fallback !== false) ? $fallback : ucfirst($groupname);
                        $this->translation[$key] = '';
                    }
                }
            }
        }
    }
577753
public function registerFieldGroups()
    {

        if (!function_exists('register_field_group')) {
            return;
        }

        $this->fieldGroups->rewind();
        while ($this->fieldGroups->valid()) {

            $field = $this->fieldGroups->current();
            register_field_group($field->getConfig());
            $this->fieldGroups->next();

        }

    }
1341483
public function indexAction()
  {
    try
    {
      /* query server logs */
      $this->tpl->ts3_logs = $this->ts3->logView(100);
    }
    catch(Exception $e)
    {
      /* save catched error mesage */
      $this->setLastEvent($e->getMessage(), TRUE);

      /* fallback to default values */
      $this->tpl->ts3_logs = array();
    }

    $this->assignLastEvent();
  }
1353305
private function clearLogs()
    {
        if (!$this->logger instanceof Logger) {
            return;
        }
        /* @var $logger Logger */
        $logger = $this->logger;

        foreach ($logger->getHandlers() as $handler) {
            if ($handler instanceof FingersCrossedHandler) {
                $handler->clear();
            }
        }
    }