Class yii\log\FileTarget

 public function __call($name, $params)
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $object) {
 if ($object->hasMethod($name)) {
 return call_user_func_array([$object, $name], $params);
 }
 }
 throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

 

 public function __clone()
{
 $this->_events = [];
 $this->_eventWildcards = [];
 $this->_behaviors = null;
}

 

 public function __construct($config = [])
{
 if (!empty($config)) {
 Yii::configure($this, $config);
 }
 $this->init();
}

 

 public function __get($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 // read property, e.g. getName()
 return $this->$getter();
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name;
 }
 }
 if (method_exists($this, 'set' . $name)) {
 throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __isset($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 return $this->$getter() !== null;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name !== null;
 }
 }
 return false;
}

 

 public function __set($name, $value)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 // set property
 $this->$setter($value);
 return;
 } elseif (strncmp($name, 'on ', 3) === 0) {
 // on event: attach event handler
 $this->on(trim(substr($name, 3)), $value);
 return;
 } elseif (strncmp($name, 'as ', 3) === 0) {
 // as behavior: attach behavior
 $name = trim(substr($name, 3));
 if ($value instanceof Behavior) {
 $this->attachBehavior($name, $value);
 } elseif ($value instanceof \Closure) {
 $this->attachBehavior($name, call_user_func($value));
 } elseif (isset($value['__class']) && is_subclass_of($value['__class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (!isset($value['__class']) && isset($value['class']) && is_subclass_of($value['class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (is_string($value) && is_subclass_of($value, Behavior::class, true)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } else {
 throw new InvalidConfigException('Class is not of type ' . Behavior::class . ' or its subclasses');
 }
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = $value;
 return;
 }
 }
 if (method_exists($this, 'get' . $name)) {
 throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __unset($name)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 $this->$setter(null);
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = null;
 return;
 }
 }
 throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

 

 public function attachBehavior($name, $behavior)
{
 $this->ensureBehaviors();
 return $this->attachBehaviorInternal($name, $behavior);
}

 

 public function attachBehaviors($behaviors)
{
 $this->ensureBehaviors();
 foreach ($behaviors as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
}

 

 public function behaviors()
{
 return [];
}

 

 public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public static function className()
{
 return get_called_class();
}

 

 public function collect($messages, $final)
{
 $this->messages = array_merge($this->messages, static::filterMessages($messages, $this->getLevels(), $this->categories, $this->except));
 $count = count($this->messages);
 if ($count > 0 && ($final || $this->exportInterval > 0 && $count >= $this->exportInterval)) {
 if (($context = $this->getContextMessage()) !== '') {
 $this->messages[] = [$context, Logger::LEVEL_INFO, 'application', YII_BEGIN_TIME, [], 0];
 }
 // set exportInterval to 0 to avoid triggering export again while exporting
 $oldExportInterval = $this->exportInterval;
 $this->exportInterval = 0;
 $this->export();
 $this->exportInterval = $oldExportInterval;
 $this->messages = [];
 }
}

 

 public function detachBehavior($name)
{
 $this->ensureBehaviors();
 if (isset($this->_behaviors[$name])) {
 $behavior = $this->_behaviors[$name];
 unset($this->_behaviors[$name]);
 $behavior->detach();
 return $behavior;
 }
 return null;
}

 

 public function detachBehaviors()
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $name => $behavior) {
 $this->detachBehavior($name);
 }
}

 

 public function ensureBehaviors()
{
 if ($this->_behaviors === null) {
 $this->_behaviors = [];
 foreach ($this->behaviors() as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
 }
}

 

 public function export()
{
 $text = implode("\n", array_map([$this, 'formatMessage'], $this->messages)) . "\n";
 if (trim($text) === '') {
 return; // No messages to export, so we exit the function early
 }
 if (strpos($this->logFile, '://') === false || strncmp($this->logFile, 'file://', 7) === 0) {
 $logPath = dirname($this->logFile);
 FileHelper::createDirectory($logPath, $this->dirMode, true);
 }
 if (($fp = @fopen($this->logFile, 'a')) === false) {
 throw new InvalidConfigException("Unable to append to log file: {$this->logFile}");
 }
 @flock($fp, LOCK_EX);
 if ($this->enableRotation) {
 // clear stat cache to ensure getting the real current file size and not a cached one
 // this may result in rotating twice when cached file size is used on subsequent calls
 clearstatcache();
 }
 if ($this->enableRotation && @filesize($this->logFile) > $this->maxFileSize * 1024) {
 $this->rotateFiles();
 }
 $writeResult = @fwrite($fp, $text);
 if ($writeResult === false) {
 $message = "Unable to export log through file ($this->logFile)!";
 if ($error = error_get_last()) {
 $message .= ": {$error['message']}";
 }
 throw new LogRuntimeException($message);
 }
 $textSize = strlen($text);
 if ($writeResult < $textSize) {
 throw new LogRuntimeException("Unable to export whole log through file ({$this->logFile})! Wrote $writeResult out of $textSize bytes.");
 }
 @fflush($fp);
 @flock($fp, LOCK_UN);
 @fclose($fp);
 if ($this->fileMode !== null) {
 @chmod($this->logFile, $this->fileMode);
 }
}

 

 public static function filterMessages($messages, $levels = 0, $categories = [], $except = [])
{
 foreach ($messages as $i => $message) {
 if ($levels && !($levels & $message[1])) {
 unset($messages[$i]);
 continue;
 }
 $matched = empty($categories);
 foreach ($categories as $category) {
 if ($message[2] === $category || !empty($category) && substr_compare($category, '*', -1, 1) === 0 && strpos($message[2], rtrim($category, '*')) === 0) {
 $matched = true;
 break;
 }
 }
 if ($matched) {
 foreach ($except as $category) {
 $prefix = rtrim($category, '*');
 if (($message[2] === $category || $prefix !== $category) && strpos($message[2], $prefix) === 0) {
 $matched = false;
 break;
 }
 }
 }
 if (!$matched) {
 unset($messages[$i]);
 }
 }
 return $messages;
}

 

 public function formatMessage($message)
{
 [$text, $level, $category, $timestamp] = $message;
 $level = Logger::getLevelName($level);
 if (!is_string($text)) {
 // exceptions may not be serializable if in the call stack somewhere is a Closure
 if ($text instanceof \Exception || $text instanceof \Throwable) {
 $text = (string) $text;
 } else {
 $text = VarDumper::export($text);
 }
 }
 $traces = [];
 if (isset($message[4])) {
 foreach ($message[4] as $trace) {
 $traces[] = "in {$trace['file']}:{$trace['line']}";
 }
 }
 $prefix = $this->getMessagePrefix($message);
 return $this->getTime($timestamp) . " {$prefix}[$level][$category] $text"
 . (empty($traces) ? '' : "\n " . implode("\n ", $traces));
}

 

 public function getBehavior($name)
{
 $this->ensureBehaviors();
 return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

 

 public function getBehaviors()
{
 $this->ensureBehaviors();
 return $this->_behaviors;
}

 

 protected function getContextMessage()
{
 $context = ArrayHelper::filter($GLOBALS, $this->logVars);
 $items = ArrayHelper::flatten($context);
 foreach ($this->maskVars as $var) {
 foreach ($items as $key => $value) {
 if (StringHelper::matchWildcard($var, $key, ['caseSensitive' => false])) {
 ArrayHelper::setValue($context, $key, '***');
 }
 }
 }
 $result = [];
 foreach ($context as $key => $value) {
 $result[] = "\${$key} = " . VarDumper::dumpAsString($value);
 }
 return implode("\n\n", $result);
}

 

 public function getEnabled()
{
 if (is_callable($this->_enabled)) {
 return call_user_func($this->_enabled, $this);
 }
 return $this->_enabled;
}

 

 public function getLevels()
{
 return $this->_levels;
}

 

 public function getMessagePrefix($message)
{
 if ($this->prefix !== null) {
 return call_user_func($this->prefix, $message);
 }
 if (Yii::$app === null) {
 return '';
 }
 $request = Yii::$app->getRequest();
 $ip = $request instanceof Request ? $request->getUserIP() : '-';
 /* @var $user \yii\web\User */
 $user = Yii::$app->has('user', true) ? Yii::$app->get('user') : null;
 if ($user && ($identity = $user->getIdentity(false))) {
 $userID = $identity->getId();
 } else {
 $userID = '-';
 }
 /* @var $session \yii\web\Session */
 $session = Yii::$app->has('session', true) ? Yii::$app->get('session') : null;
 $sessionID = $session && $session->getIsActive() ? $session->getId() : '-';
 return "[$ip][$userID][$sessionID]";
}

 

 protected function getTime($timestamp)
{
 $parts = explode('.', sprintf('%F', $timestamp));
 return date('Y-m-d H:i:s', $parts[0]) . ($this->microtime ? ('.' . $parts[1]) : '');
}

 

 public function hasEventHandlers($name)
{
 $this->ensureBehaviors();
 if (!empty($this->_events[$name])) {
 return true;
 }
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
 return true;
 }
 }
 return Event::hasHandlers($this, $name);
}

 

 public function hasMethod($name, $checkBehaviors = true)
{
 if (method_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->hasMethod($name)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
 return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

 

 public function init()
{
 parent::init();
 if ($this->logFile === null) {
 $this->logFile = Yii::$app->getRuntimePath() . '/logs/app.log';
 } else {
 $this->logFile = Yii::getAlias($this->logFile);
 }
 if ($this->maxLogFiles < 1) {
 $this->maxLogFiles = 1;
 }
 if ($this->maxFileSize < 1) {
 $this->maxFileSize = 1;
 }
}

 

 public function off($name, $handler = null)
{
 $this->ensureBehaviors();
 if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
 return false;
 }
 if ($handler === null) {
 unset($this->_events[$name], $this->_eventWildcards[$name]);
 return true;
 }
 $removed = false;
 // plain event names
 if (isset($this->_events[$name])) {
 foreach ($this->_events[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_events[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_events[$name] = array_values($this->_events[$name]);
 return true;
 }
 }
 // wildcard event names
 if (isset($this->_eventWildcards[$name])) {
 foreach ($this->_eventWildcards[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_eventWildcards[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
 // remove empty wildcards to save future redundant regex checks:
 if (empty($this->_eventWildcards[$name])) {
 unset($this->_eventWildcards[$name]);
 }
 }
 }
 return $removed;
}

 

 public function on($name, $handler, $data = null, $append = true)
{
 $this->ensureBehaviors();
 if (strpos($name, '*') !== false) {
 if ($append || empty($this->_eventWildcards[$name])) {
 $this->_eventWildcards[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_eventWildcards[$name], [$handler, $data]);
 }
 return;
 }
 if ($append || empty($this->_events[$name])) {
 $this->_events[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_events[$name], [$handler, $data]);
 }
}

 

 protected function rotateFiles()
{
 $file = $this->logFile;
 for ($i = $this->maxLogFiles; $i >= 0; --$i) {
 // $i == 0 is the original log file
 $rotateFile = $file . ($i === 0 ? '' : '.' . $i);
 if (is_file($rotateFile)) {
 // suppress errors because it's possible multiple processes enter into this section
 if ($i === $this->maxLogFiles) {
 @unlink($rotateFile);
 continue;
 }
 $newFile = $this->logFile . '.' . ($i + 1);
 $this->rotateByCopy($rotateFile, $newFile);
 if ($i === 0) {
 $this->clearLogFile($rotateFile);
 }
 }
 }
}

 

 public function setEnabled($value)
{
 $this->_enabled = $value;
}

 

 public function setLevels($levels)
{
 static $levelMap = [
 'error' => Logger::LEVEL_ERROR,
 'warning' => Logger::LEVEL_WARNING,
 'info' => Logger::LEVEL_INFO,
 'trace' => Logger::LEVEL_TRACE,
 'profile' => Logger::LEVEL_PROFILE,
 ];
 if (is_array($levels)) {
 $this->_levels = 0;
 foreach ($levels as $level) {
 if (isset($levelMap[$level])) {
 $this->_levels |= $levelMap[$level];
 } else {
 throw new InvalidConfigException("Unrecognized level: $level");
 }
 }
 } else {
 $bitmapValues = array_reduce($levelMap, function ($carry, $item) {
 return $carry | $item;
 });
 if (!($bitmapValues & $levels) && $levels !== 0) {
 throw new InvalidConfigException("Incorrect $levels value");
 }
 $this->_levels = $levels;
 }
}

 

 public function trigger($name, ?Event $event = null)
{
 $this->ensureBehaviors();
 $eventHandlers = [];
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (StringHelper::matchWildcard($wildcard, $name)) {
 $eventHandlers[] = $handlers;
 }
 }
 if (!empty($this->_events[$name])) {
 $eventHandlers[] = $this->_events[$name];
 }
 if (!empty($eventHandlers)) {
 $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
 if ($event === null) {
 $event = new Event();
 }
 if ($event->sender === null) {
 $event->sender = $this;
 }
 $event->handled = false;
 $event->name = $name;
 foreach ($eventHandlers as $handler) {
 $event->data = $handler[1];
 call_user_func($handler[0], $event);
 // stop further handling if the event is handled
 if ($event->handled) {
 return;
 }
 }
 }
 // invoke class-level attached handlers
 Event::trigger($this, $name, $event);
}