function RulesDebugLoggerChannel::log

Parent log() function is overridden to use microtime() for Rules execution times and to prepare additional variables to pass to the logger. These variables hold the extra call parameters used by RulesDebugLog for backtracing. These are passed in via $context[] where they will be ignored by any module that doesn't know about them ...

Overrides LoggerChannel::log

File

src/Logger/RulesDebugLoggerChannel.php, line 52

Class

RulesDebugLoggerChannel

Logs rules log entries in the available loggers.

Namespace

Code

public function log($level, $message, array $context = []) : void {
    // Log debugging information only if the debug_log.enabled setting is
    // enabled. Otherwise exit immediately.
    $config = $this->config
        ->get('rules.settings');
    if (!$config->get('debug_log.enabled')) {
        return;
    }
    if ($this->callDepth == self::MAX_CALL_DEPTH) {
        return;
    }
    $this->callDepth++;
    // Merge in defaults normally provided by the parent LoggerChannel class.
    $context += [
        'channel' => $this->channel,
        'link' => '',
        'uid' => 0,
        'request_uri' => '',
        'referer' => '',
        'ip' => '',
        'timestamp' => microtime(TRUE),
    ];
    // Some context values are only available when in a request context.
    if ($this->requestStack && ($request = $this->requestStack
        ->getCurrentRequest())) {
        $context['request_uri'] = $request->getUri();
        $context['referer'] = $request->headers
            ->get('Referer', '');
        $context['ip'] = $request->getClientIP();
        if ($this->currentUser) {
            $context['uid'] = $this->currentUser
                ->id();
        }
    }
    // Extract the Rules-specific defaults from $context.
    $element = $context['element'] ?? NULL;
    $scope = $context['scope'] ?? NULL;
    $path = $context['path'] ?? NULL;
    if (!empty($element)) {
        // Need to know if we're in a Reaction Rule or a Rules Component, and need
        // to be able to get a reference to that specific entity. For now we just
        // assume Reaction Rule until we know how to do this better.
        $path = $element->getRoot()
            ->getLabel() ? Url::fromRoute('entity.rules_reaction_rule.edit_form.expression.edit', [
            'rules_reaction_rule' => $element->getRoot()
                ->getPluginId(),
            'uuid' => $element->getUuid(),
        ])
            ->toString() : NULL;
    }
    // Pack $element, $scope, and $path into the context array so as to forward
    // them to the logger.channel.rules_debug logger channel for logging.
    $context += [
        'element' => $element,
        'scope' => $scope,
        'path' => $path,
    ];
    // Now, write the logs to the RulesDebugLog to store in memory. This is the
    // principal reason for this class! Keep the array structure we used in D7
    // so we don't have to re-write the theming functions and JavaScript too
    // much. We added keys for D8 so we don't have to guess the contents of the
    // array elements from their order index.
    $rfc_level = $level;
    if (is_string($level)) {
        // Convert to integer equivalent for consistency with RFC 5424.
        $rfc_level = $this->levelTranslation[$level];
    }
    // A lesser RFC level is MORE severe, so we want to test if the RFC level
    // of the message is LESS than or equal to the threshold level setting.
    if ($this->levelTranslation[$config->get('debug_log.log_level')] >= $rfc_level) {
        $this->rulesDebugLog
            ->log($level, $message, $context);
        // Support any loggers added through the API, just because we can (most
        // of this is inherited from parent LoggerChannel class).
        foreach ($this->sortLoggers() as $logger) {
            $logger->log($rfc_level, $message, $context);
        }
    }
    $this->callDepth--;
}