class BufferLogger in TMGMT Translator Smartling 8.4

Class BufferLogger

@package Drupal\tmgmt_smartling\Logger

Hierarchy

• class \Drupal\tmgmt_smartling\Logger\BufferLogger implements LoggerInterface uses LoggerTrait

1 string reference to 'BufferLogger'

tmgmt_smartling.services.yml in ./tmgmt_smartling.services.yml

tmgmt_smartling.services.yml

1 service uses BufferLogger

logger.smartling in ./tmgmt_smartling.services.yml

Drupal\tmgmt_smartling\Logger\BufferLogger

File

src/Logger/BufferLogger.php, line 22

Namespace

Drupal\tmgmt_smartling\Logger

class BufferLogger implements LoggerInterface {
  use LoggerTrait;

  /**
   * Map of RFC 5424 log constants to PSR3 log constants.
   *
   * @var array
   */
  protected $levelTranslation = [
    RfcLogLevel::EMERGENCY => LogLevel::EMERGENCY,
    RfcLogLevel::ALERT => LogLevel::ALERT,
    RfcLogLevel::CRITICAL => LogLevel::CRITICAL,
    RfcLogLevel::ERROR => LogLevel::ERROR,
    RfcLogLevel::WARNING => LogLevel::WARNING,
    RfcLogLevel::NOTICE => LogLevel::NOTICE,
    RfcLogLevel::INFO => LogLevel::INFO,
    RfcLogLevel::DEBUG => LogLevel::DEBUG,
  ];

  /**
   * @var array
   */
  private $buffer;

  /**
   * @var int
   */
  private $bufferLimit;

  /**
   * @var array
   */
  private $channels;

  /**
   * @var int
   */
  private $timeOut;

  /**
   * @var LogMessageParserInterface
   */
  private $parser;

  /**
   * @var ConfigFactoryInterface
   */
  private $configFactory;

  /**
   * @var array
   */
  private $providerSettings = [];

  /**
   * @var RequestStack
   */
  private $requestStack;

  /**
   * @var int
   */
  private $logLevel;

  /**
   * @var string
   */
  private $host;

  /**
   * @var Client
   */
  private $httpClient;

  /**
   * @var string
   */
  private $uid;

  /**
   * @var SmartlingConfigManager
   */
  private $configManager;

  /**
   * BufferLogger constructor.
   *
   * @param Client $http_client
   * @param LogMessageParserInterface $parser
   * @param ConfigFactoryInterface $config_factory
   * @param RequestStack $request_stack
   * @param array $channels
   * @param int $log_level
   * @param string $host
   * @param int $buffer_limit
   * @param int $time_out
   */
  public function __construct(Client $http_client, LogMessageParserInterface $parser, ConfigFactoryInterface $config_factory, RequestStack $request_stack, $channels = [
    'tmgmt_smartling',
    'tmgmt_smartling_context_debug',
    'tmgmt_extension_suit',
    'smartling_api',
  ], $log_level = RfcLogLevel::DEBUG, $host = 'https://api.smartling.com/updates/status', $buffer_limit = 100, $time_out = 5) {
    $this->buffer = [];
    $this->httpClient = $http_client;
    $this->channels = $channels;
    $this->parser = $parser;
    $this->configFactory = $config_factory;
    $this->requestStack = $request_stack;
    $this->logLevel = $log_level;
    $this->host = $host;
    $this->bufferLimit = $buffer_limit;
    $this->timeOut = $time_out;
    $this->uid = uniqid();
    drupal_register_shutdown_function([
      $this,
      'flush',
    ]);
  }

  /**
   * Setter for config manager.
   *
   * @param \Drupal\tmgmt_smartling\Smartling\ConfigManager\SmartlingConfigManager $config_manager
   */
  public function setConfigManager(SmartlingConfigManager $config_manager) {
    $this->configManager = $config_manager;

    // Pick up first available Smartling provider settings.
    $smartling_provider = $this->configManager
      ->getAvailableConfigs();
    if (!empty($smartling_provider)) {
      $this->providerSettings = $smartling_provider[0]
        ->get();
    }
  }

  /**
   * Logs with an arbitrary level.
   *
   * @param mixed $level
   * @param string $message
   * @param array $context
   *
   * @return void
   */
  public function log($level, $message, array $context = []) {

    // Log only records from needed channels.
    if (empty($this->channels) || in_array($context['channel'], $this->channels)) {

      // Key "enable_smartling_logging" might be absent in provider settings
      // after module update. Consider this situation as "checked" by default.
      $logging_key_is_not_set = !isset($this->providerSettings['settings']['enable_smartling_logging']);
      $enabled_logging = $logging_key_is_not_set || $this->providerSettings['settings']['enable_smartling_logging'] === TRUE;

      // Buffer log records with $this->log_level or lover.
      if ($level <= $this->logLevel && !empty($this->providerSettings['settings']['project_id']) && $enabled_logging) {
        $this->buffer[] = [
          'level' => $level,
          'message' => $message,
          'context' => $context,
        ];

        // Flush buffer on overflow.
        if (count($this->buffer) == $this->bufferLimit) {
          $this
            ->flush();
        }
      }
    }
  }

  /**
   * Log messages into needed destination.
   */
  public function flush() {
    if (empty($this->buffer)) {
      return;
    }
    try {
      $records = [];
      $project_id = $this->providerSettings['settings']['project_id'];
      $host = php_uname('n');
      $http_host = $this->requestStack
        ->getCurrentRequest()
        ->getHost();
      $tmgmt_smartling_version = ConnectorInfo::getLibVersion();
      $dependencies = ConnectorInfo::getDependenciesVersionsAsString();

      // Assemble records.
      foreach ($this->buffer as $drupal_log_record) {
        $message_placeholders = $this->parser
          ->parseMessagePlaceholders($drupal_log_record['message'], $drupal_log_record['context']);
        $records[] = [
          'level_name' => $this->levelTranslation[$drupal_log_record['level']],
          'channel' => 'drupal-tmgmt-connector',
          'datetime' => date('Y-m-d H:i:s', $drupal_log_record['context']['timestamp']),
          'context' => [
            'projectId' => $project_id,
            'host' => $host,
            'http_host' => $http_host,
            'moduleVersion' => $tmgmt_smartling_version,
            'dependencies' => $dependencies,
            'remoteChannel' => $drupal_log_record['context']['channel'],
            'requestId' => $this->uid,
          ],
          'message' => strtr($drupal_log_record['message'], $message_placeholders),
        ];
      }
      $this->httpClient
        ->request('POST', $this->host, [
        'json' => [
          'records' => $records,
        ],
        'timeout' => $this->timeOut,
        'headers' => [
          'User-Agent' => ConnectorInfo::getLibName() . '/' . ConnectorInfo::getLibVersion(),
        ],
      ]);
    } catch (Exception $e) {
    }
    $this->buffer = [];
  }

}

Members

Name	Modifiers	Type	Description	Overrides
BufferLogger::$buffer	private	property
BufferLogger::$bufferLimit	private	property
BufferLogger::$channels	private	property
BufferLogger::$configFactory	private	property
BufferLogger::$configManager	private	property
BufferLogger::$host	private	property
BufferLogger::$httpClient	private	property
BufferLogger::$levelTranslation	protected	property	Map of RFC 5424 log constants to PSR3 log constants.
BufferLogger::$logLevel	private	property
BufferLogger::$parser	private	property
BufferLogger::$providerSettings	private	property
BufferLogger::$requestStack	private	property
BufferLogger::$timeOut	private	property
BufferLogger::$uid	private	property
BufferLogger::flush	public	function	Log messages into needed destination.
BufferLogger::log	public	function	Logs with an arbitrary level. Overrides LoggerTrait::log
BufferLogger::setConfigManager	public	function	Setter for config manager.
BufferLogger::__construct	public	function	BufferLogger constructor.
LoggerTrait::alert	public	function	Action must be taken immediately.
LoggerTrait::critical	public	function	Critical conditions.
LoggerTrait::debug	public	function	Detailed debug information.
LoggerTrait::emergency	public	function	System is unusable.
LoggerTrait::error	public	function	Runtime errors that do not require immediate action but should typically be logged and monitored.
LoggerTrait::info	public	function	Interesting events.
LoggerTrait::notice	public	function	Normal but significant events.
LoggerTrait::warning	public	function	Exceptional occurrences that are not errors.