use OCP\DB\QueryBuilder\IParameter;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\DB\QueryBuilder\IQueryFunction;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class QueryBuilder implements IQueryBuilder {
/** @var SystemConfig */
private $systemConfig;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var \Doctrine\DBAL\Query\QueryBuilder */
private $queryBuilder;
*
* @param ConnectionAdapter $connection
* @param SystemConfig $systemConfig
- * @param ILogger $logger
*/
- public function __construct(ConnectionAdapter $connection, SystemConfig $systemConfig, ILogger $logger) {
+ public function __construct(ConnectionAdapter $connection, SystemConfig $systemConfig, LoggerInterface $logger) {
$this->connection = $connection;
$this->systemConfig = $systemConfig;
$this->logger = $logger;
}
} catch (\Error $e) {
// likely an error during conversion of $value to string
- $this->logger->debug('DB QueryBuilder: error trying to log SQL query');
- $this->logger->logException($e);
+ $this->logger->debug('DB QueryBuilder: error trying to log SQL query', ['exception' => $e]);
}
}
if (empty($hasSelectAll) === empty($hasSelectSpecific)) {
$exception = new QueryException('Query is selecting * and specific values in the same query. This is not supported in Oracle.');
- $this->logger->logException($exception, [
- 'message' => 'Query is selecting * and specific values in the same query. This is not supported in Oracle.',
+ $this->logger->error($exception->getMessage(), [
'query' => $this->getSQL(),
- 'level' => ILogger::ERROR,
'app' => 'core',
+ 'exception' => $exception,
]);
}
}
if ($hasTooLargeArrayParameter) {
$exception = new QueryException('More than 1000 expressions in a list are not allowed on Oracle.');
- $this->logger->logException($exception, [
- 'message' => 'More than 1000 expressions in a list are not allowed on Oracle.',
+ $this->logger->error($exception->getMessage(), [
'query' => $this->getSQL(),
- 'level' => ILogger::ERROR,
'app' => 'core',
+ 'exception' => $exception,
]);
}
if ($numberOfParameters > 65535) {
$exception = new QueryException('The number of parameters must not exceed 65535. Restriction by PostgreSQL.');
- $this->logger->logException($exception, [
- 'message' => 'The number of parameters must not exceed 65535. Restriction by PostgreSQL.',
+ $this->logger->error($exception->getMessage(), [
'query' => $this->getSQL(),
- 'level' => ILogger::ERROR,
'app' => 'core',
+ 'exception' => $exception,
]);
}
use OC\Memcache\ArrayCache;
use OCP\Files\Mount\IMountPoint;
use OCP\Files\Storage;
-use OCP\ILogger;
use Psr\Log\LoggerInterface;
/**
/** @var Manager */
private $manager;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/**
* EncryptionWrapper constructor.
- *
- * @param ArrayCache $arrayCache
- * @param Manager $manager
- * @param ILogger $logger
*/
public function __construct(ArrayCache $arrayCache,
Manager $manager,
- ILogger $logger
+ LoggerInterface $logger
) {
$this->arrayCache = $arrayCache;
$this->manager = $manager;
Filesystem::getMountManager(),
$this->manager,
$fileHelper,
- \OC::$server->get(LoggerInterface::class),
+ $this->logger,
$uid
);
return new Encryption(
use OCP\Encryption\IManager;
use OCP\IConfig;
use OCP\IL10N;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class Manager implements IManager {
/** @var IConfig */
protected $config;
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var Il10n */
protected $l;
/** @var ArrayCache */
protected $arrayCache;
- /**
- * @param IConfig $config
- * @param ILogger $logger
- * @param IL10N $l10n
- * @param View $rootView
- * @param Util $util
- * @param ArrayCache $arrayCache
- */
- public function __construct(IConfig $config, ILogger $logger, IL10N $l10n, View $rootView, Util $util, ArrayCache $arrayCache) {
+ public function __construct(IConfig $config, LoggerInterface $logger, IL10N $l10n, View $rootView, Util $util, ArrayCache $arrayCache) {
$this->encryptionModules = [];
$this->config = $config;
$this->logger = $logger;
*/
namespace OC\EventDispatcher;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\GenericEvent;
class GenericEventWrapper extends GenericEvent {
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var GenericEvent */
private $event;
/** @var bool */
private $deprecationNoticeLogged = false;
- public function __construct(ILogger $logger, string $eventName, ?GenericEvent $event) {
+ public function __construct(LoggerInterface $logger, string $eventName, ?GenericEvent $event) {
parent::__construct($eventName);
$this->logger = $logger;
$this->event = $event;
*/
namespace OC\EventDispatcher;
-use Symfony\Component\EventDispatcher\GenericEvent;
-use function is_callable;
use OCP\EventDispatcher\Event;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\EventDispatcher\GenericEvent;
+use function is_callable;
use function is_object;
use function is_string;
/** @var EventDispatcher */
private $eventDispatcher;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/**
* @deprecated 20.0.0
*/
- public function __construct(EventDispatcher $eventDispatcher, ILogger $logger) {
+ public function __construct(EventDispatcher $eventDispatcher, LoggerInterface $logger) {
$this->eventDispatcher = $eventDispatcher;
$this->logger = $logger;
}
use OCP\Federation\ICloudFederationShare;
use OCP\Federation\ICloudIdManager;
use OCP\Http\Client\IClientService;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
/**
* Class Manager
/** @var ICloudIdManager */
private $cloudIdManager;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var array cache OCM end-points */
private $ocmEndPoints = [];
* @param IAppManager $appManager
* @param IClientService $httpClientService
* @param ICloudIdManager $cloudIdManager
- * @param ILogger $logger
*/
public function __construct(IAppManager $appManager,
IClientService $httpClientService,
ICloudIdManager $cloudIdManager,
- ILogger $logger) {
+ LoggerInterface $logger) {
$this->cloudFederationProvider = [];
$this->appManager = $appManager;
$this->httpClientService = $httpClientService;
// we re-throw the exception and fall back to the old behaviour.
// (flat re-shares has been introduced in Nextcloud 9.1)
if ($e->getCode() === Http::STATUS_INTERNAL_SERVER_ERROR) {
- $this->logger->debug($e->getMessage());
+ $this->logger->debug($e->getMessage(), ['exception' => $e]);
throw $e;
}
}
}
} catch (\Exception $e) {
// log the error and return false
- $this->logger->error('error while sending notification for federated share: ' . $e->getMessage());
+ $this->logger->error('error while sending notification for federated share: ' . $e->getMessage(), ['exception' => $e]);
}
return false;
use OC\SystemConfig;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
/**
* Query builder with commonly used helpers for filecache queries
class CacheQueryBuilder extends QueryBuilder {
private $alias = null;
- public function __construct(IDBConnection $connection, SystemConfig $systemConfig, ILogger $logger) {
+ public function __construct(IDBConnection $connection, SystemConfig $systemConfig, LoggerInterface $logger) {
parent::__construct($connection, $systemConfig, $logger);
}
use OCP\Files\Search\ISearchBinaryOperator;
use OCP\Files\Search\ISearchQuery;
use OCP\IDBConnection;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class QuerySearchHelper {
private $connection;
/** @var SystemConfig */
private $systemConfig;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var SearchBuilder */
private $searchBuilder;
/** @var QueryOptimizer */
IMimeTypeLoader $mimetypeLoader,
IDBConnection $connection,
SystemConfig $systemConfig,
- ILogger $logger,
+ LoggerInterface $logger,
SearchBuilder $searchBuilder,
QueryOptimizer $queryOptimizer
) {
use OCP\Files\NotFoundException;
use OCP\ICache;
use OCP\IDBConnection;
-use OCP\ILogger;
use OCP\IUser;
use OCP\IUserManager;
+use Psr\Log\LoggerInterface;
/**
* Cache mounts points per user in the cache so we can easilly look them up
**/
private $mountsForUsers;
- /**
- * @var ILogger
- */
- private $logger;
+ private LoggerInterface $logger;
/**
* @var ICache
/**
* UserMountCache constructor.
- *
- * @param IDBConnection $connection
- * @param IUserManager $userManager
- * @param ILogger $logger
*/
- public function __construct(IDBConnection $connection, IUserManager $userManager, ILogger $logger) {
+ public function __construct(IDBConnection $connection, IUserManager $userManager, LoggerInterface $logger) {
$this->connection = $connection;
$this->userManager = $userManager;
$this->logger = $logger;
use OCP\Files\Config\IRootMountProvider;
use OCP\Files\Storage\IStorageFactory;
use OCP\IConfig;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
/**
* Mount provider for object store app data folder for previews
*/
class ObjectStorePreviewCacheMountProvider implements IRootMountProvider {
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var IConfig */
private $config;
- public function __construct(ILogger $logger, IConfig $config) {
+ public function __construct(LoggerInterface $logger, IConfig $config) {
$this->logger = $logger;
$this->config = $config;
}
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
-use OCP\ILogger;
use OCP\IUser;
use OCP\IUserManager;
+use Psr\Log\LoggerInterface;
/**
* Class Root
private ?IUser $user;
private CappedMemoryCache $userFolderCache;
private IUserMountCache $userMountCache;
- private ILogger $logger;
+ private LoggerInterface $logger;
private IUserManager $userManager;
private IEventDispatcher $eventDispatcher;
* @param Manager $manager
* @param View $view
* @param IUser|null $user
- * @param IUserMountCache $userMountCache
- * @param ILogger $logger
- * @param IUserManager $userManager
*/
public function __construct(
$manager,
$view,
$user,
IUserMountCache $userMountCache,
- ILogger $logger,
+ LoggerInterface $logger,
IUserManager $userManager,
IEventDispatcher $eventDispatcher
) {
use OCP\Files\StorageAuthException;
use OCP\Files\StorageNotAvailableException;
use OCP\ICache;
-use OCP\ILogger;
use OpenStack\Common\Auth\Token;
use OpenStack\Common\Error\BadResponseError;
use OpenStack\Common\Transport\Utils as TransportUtils;
use OpenStack\ObjectStore\v1\Models\Container;
use OpenStack\OpenStack;
use Psr\Http\Message\RequestInterface;
+use Psr\Log\LoggerInterface;
class SwiftFactory {
private $cache;
private $params;
/** @var Container|null */
private $container = null;
- private $logger;
+ private LoggerInterface $logger;
public const DEFAULT_OPTIONS = [
'autocreate' => false,
'catalogType' => 'object-store'
];
- public function __construct(ICache $cache, array $params, ILogger $logger) {
+ public function __construct(ICache $cache, array $params, LoggerInterface $logger) {
$this->cache = $cache;
$this->params = $params;
$this->logger = $logger;
$this->logger->debug('Cached token for swift expired');
}
} catch (\Exception $e) {
- $this->logger->logException($e);
+ $this->logger->error($e->getMessage(), ['exception' => $e]);
}
}
}
/** @var RequestInterface $request */
$request = $e->getRequest();
$host = $request->getUri()->getHost() . ':' . $request->getUri()->getPort();
- \OC::$server->getLogger()->error("Can't connect to object storage server at $host");
+ $this->logger->error("Can't connect to object storage server at $host", ['exception' => $e]);
throw new StorageNotAvailableException("Can't connect to object storage server at $host", StorageNotAvailableException::STATUS_ERROR, $e);
}
}
use OCP\Files\Cache\ICacheEntry;
use OCP\Files\Mount\IMountPoint;
use OCP\Files\Storage;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class Encryption extends Wrapper {
use LocalTempFileTrait;
/** @var \OCP\Encryption\IManager */
private $encryptionManager;
- /** @var \OCP\ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var string */
private $uid;
/**
* @param array $parameters
- * @param IManager $encryptionManager
- * @param Util $util
- * @param ILogger $logger
- * @param IFile $fileHelper
- * @param string $uid
- * @param IStorage $keyStorage
- * @param Update $update
- * @param Manager $mountManager
- * @param ArrayCache $arrayCache
*/
public function __construct(
$parameters,
- IManager $encryptionManager = null,
- Util $util = null,
- ILogger $logger = null,
- IFile $fileHelper = null,
- $uid = null,
- IStorage $keyStorage = null,
- Update $update = null,
- Manager $mountManager = null,
- ArrayCache $arrayCache = null
+ IManager $encryptionManager,
+ Util $util,
+ LoggerInterface $logger,
+ IFile $fileHelper,
+ string $uid,
+ IStorage $keyStorage,
+ Update $update,
+ Manager $mountManager,
+ ArrayCache $arrayCache
) {
$this->mountPoint = $parameters['mountPoint'];
$this->mount = $parameters['mount'];
}
}
} catch (ModuleDoesNotExistsException $e) {
- $this->logger->logException($e, [
- 'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
- 'level' => ILogger::WARN,
+ $this->logger->warning('Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted', [
+ 'exception' => $e,
'app' => 'core',
]);
}
try {
$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
} catch (\Exception $e) {
- $this->logger->error('Couldn\'t re-calculate unencrypted size for ' . $path);
- $this->logger->logException($e);
+ $this->logger->error('Couldn\'t re-calculate unencrypted size for ' . $path, ['exception' => $e]);
}
unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
}
namespace OC\Files\Type;
use OCP\Files\IMimeTypeDetector;
-use OCP\ILogger;
use OCP\IURLGenerator;
+use Psr\Log\LoggerInterface;
/**
* Class Detection
/** @var IURLGenerator */
private $urlGenerator;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var string */
private $customConfigDir;
/** @var string */
private $defaultConfigDir;
- /**
- * @param IURLGenerator $urlGenerator
- * @param ILogger $logger
- * @param string $customConfigDir
- * @param string $defaultConfigDir
- */
public function __construct(IURLGenerator $urlGenerator,
- ILogger $logger,
+ LoggerInterface $logger,
string $customConfigDir,
string $defaultConfigDir) {
$this->urlGenerator = $urlGenerator;
use OCP\Files\Storage\IStorage;
use OCP\Files\StorageNotAvailableException;
use OCP\IDBConnection;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
/**
* Class Scanner
/** @var IEventDispatcher */
private $dispatcher;
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/**
* Whether to use a DB transaction
* @param string $user
* @param IDBConnection|null $db
* @param IEventDispatcher $dispatcher
- * @param ILogger $logger
*/
- public function __construct($user, $db, IEventDispatcher $dispatcher, ILogger $logger) {
+ public function __construct($user, $db, IEventDispatcher $dispatcher, LoggerInterface $logger) {
$this->user = $user;
$this->db = $db;
$this->dispatcher = $dispatcher;
}
$propagator->commitBatch();
} catch (StorageNotAvailableException $e) {
- $this->logger->error('Storage ' . $storage->getId() . ' not available');
- $this->logger->logException($e);
+ $this->logger->error('Storage ' . $storage->getId() . ' not available', ['exception' => $e]);
$this->emit('\OC\Files\Utils\Scanner', 'StorageNotAvailable', [$e]);
}
if ($this->useTransaction) {
use OCP\GroupInterface;
use OCP\IGroup;
use OCP\IGroupManager;
-use OCP\ILogger;
use OCP\IUser;
+use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
/**
private $userManager;
/** @var EventDispatcherInterface */
private $dispatcher;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var \OC\Group\Group[] */
private $cachedGroups = [];
/** @var \OC\SubAdmin */
private $subAdmin = null;
- /**
- * @param \OC\User\Manager $userManager
- * @param EventDispatcherInterface $dispatcher
- * @param ILogger $logger
- */
public function __construct(\OC\User\Manager $userManager,
EventDispatcherInterface $dispatcher,
- ILogger $logger) {
+ LoggerInterface $logger) {
$this->userManager = $userManager;
$this->dispatcher = $dispatcher;
$this->logger = $logger;
use OCP\Http\Client\IResponse;
use OCP\ICertificateManager;
use OCP\IConfig;
-use OCP\ILogger;
/**
* Class Client
private $client;
/** @var IConfig */
private $config;
- /** @var ILogger */
- private $logger;
/** @var ICertificateManager */
private $certificateManager;
/** @var LocalAddressChecker */
public function __construct(
IConfig $config,
- ILogger $logger,
ICertificateManager $certificateManager,
GuzzleClient $client,
LocalAddressChecker $localAddressChecker
) {
$this->config = $config;
- $this->logger = $logger;
$this->client = $client;
$this->certificateManager = $certificateManager;
$this->localAddressChecker = $localAddressChecker;
use OCP\Http\Client\IClientService;
use OCP\ICertificateManager;
use OCP\IConfig;
-use OCP\ILogger;
/**
* Class ClientService
class ClientService implements IClientService {
/** @var IConfig */
private $config;
- /** @var ILogger */
- private $logger;
/** @var ICertificateManager */
private $certificateManager;
/** @var DnsPinMiddleware */
private $localAddressChecker;
public function __construct(IConfig $config,
- ILogger $logger,
ICertificateManager $certificateManager,
DnsPinMiddleware $dnsPinMiddleware,
LocalAddressChecker $localAddressChecker) {
$this->config = $config;
- $this->logger = $logger;
$this->certificateManager = $certificateManager;
$this->dnsPinMiddleware = $dnsPinMiddleware;
$this->localAddressChecker = $localAddressChecker;
return new Client(
$this->config,
- $this->logger,
$this->certificateManager,
$client,
$this->localAddressChecker
*/
namespace OC\Http\Client;
-use OCP\ILogger;
use OCP\Http\Client\LocalServerException;
+use Psr\Log\LoggerInterface;
class LocalAddressChecker {
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
- public function __construct(ILogger $logger) {
+ public function __construct(LoggerInterface $logger) {
$this->logger = $logger;
}
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
-use OCP\ILogger;
use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
+use Psr\Log\LoggerInterface;
/**
* Locking provider that stores the locks in the database
*/
private $connection;
- /**
- * @var \OCP\ILogger
- */
- private $logger;
+ private LoggerInterface $logger;
/**
* @var \OCP\AppFramework\Utility\ITimeFactory
}
/**
- * @param \OCP\IDBConnection $connection
- * @param \OCP\ILogger $logger
- * @param \OCP\AppFramework\Utility\ITimeFactory $timeFactory
- * @param int $ttl
* @param bool $cacheSharedLocks
*/
public function __construct(
IDBConnection $connection,
- ILogger $logger,
+ LoggerInterface $logger,
ITimeFactory $timeFactory,
int $ttl = 3600,
$cacheSharedLocks = true
use OCP\EventDispatcher\IEventDispatcher;
use OCP\IConfig;
use OCP\IL10N;
-use OCP\ILogger;
use OCP\IURLGenerator;
use OCP\L10N\IFactory;
use OCP\Mail\Events\BeforeMessageSent;
use OCP\Mail\IEMailTemplate;
use OCP\Mail\IMailer;
use OCP\Mail\IMessage;
+use Psr\Log\LoggerInterface;
/**
* Class Mailer provides some basic functions to create a mail message that can be used in combination with
private $instance = null;
/** @var IConfig */
private $config;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var Defaults */
private $defaults;
/** @var IURLGenerator */
/** @var IFactory */
private $l10nFactory;
- /**
- * @param IConfig $config
- * @param ILogger $logger
- * @param Defaults $defaults
- * @param IURLGenerator $urlGenerator
- * @param IL10N $l10n
- * @param IEventDispatcher $dispatcher
- */
public function __construct(IConfig $config,
- ILogger $logger,
+ LoggerInterface $logger,
Defaults $defaults,
IURLGenerator $urlGenerator,
IL10N $l10n,
use OCP\ICache;
use OCP\ICacheFactory;
-use OCP\ILogger;
use OCP\IMemcache;
+use Psr\Log\LoggerInterface;
class Factory implements ICacheFactory {
public const NULL_CACHE = NullCache::class;
*/
private $globalPrefix;
- /**
- * @var ILogger $logger
- */
- private $logger;
+ private LoggerInterface $logger;
/**
* @var string $localCacheClass
/** @var string */
private $logFile;
- /**
- * @param string $globalPrefix
- * @param ILogger $logger
- * @param string|null $localCacheClass
- * @param string|null $distributedCacheClass
- * @param string|null $lockingCacheClass
- * @param string $logFile
- */
- public function __construct(string $globalPrefix, ILogger $logger,
- $localCacheClass = null, $distributedCacheClass = null, $lockingCacheClass = null, string $logFile = '') {
+ public function __construct(
+ string $globalPrefix,
+ LoggerInterface $logger,
+ ?string $localCacheClass = null,
+ ?string $distributedCacheClass = null,
+ ?string $lockingCacheClass = null,
+ string $logFile = ''
+ ) {
$this->logger = $logger;
$this->logFile = $logFile;
$this->globalPrefix = $globalPrefix;
*/
namespace OC\Migration;
-use OCP\ILogger;
use OCP\Migration\IOutput;
+use Psr\Log\LoggerInterface;
/**
* Class SimpleOutput
*/
class SimpleOutput implements IOutput {
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
private $appName;
- public function __construct(ILogger $logger, $appName) {
+ public function __construct(LoggerInterface $logger, $appName) {
$this->logger = $logger;
$this->appName = $appName;
}
use Doctrine\DBAL\Platforms\MySQLPlatform;
use OCP\IConfig;
use OCP\IDBConnection;
-use OCP\ILogger;
use OCP\Migration\IOutput;
use OCP\Migration\IRepairStep;
+use Psr\Log\LoggerInterface;
class Collation implements IRepairStep {
/** @var IConfig */
protected $config;
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var IDBConnection */
protected $connection;
protected $ignoreFailures;
/**
- * @param IConfig $config
- * @param ILogger $logger
- * @param IDBConnection $connection
* @param bool $ignoreFailures
*/
- public function __construct(IConfig $config, ILogger $logger, IDBConnection $connection, $ignoreFailures) {
+ public function __construct(
+ IConfig $config,
+ LoggerInterface $logger,
+ IDBConnection $connection,
+ $ignoreFailures
+ ) {
$this->connection = $connection;
$this->config = $config;
$this->logger = $logger;
$query->execute();
} catch (DriverException $e) {
// Just log this
- $this->logger->logException($e);
+ $this->logger->error($e->getMessage(), ['exception' => $e]);
if (!$this->ignoreFailures) {
throw $e;
}
$query->execute();
} catch (DriverException $e) {
// Just log this
- $this->logger->logException($e);
+ $this->logger->error($e->getMessage(), ['exception' => $e]);
if (!$this->ignoreFailures) {
throw $e;
}
use OCP\Files\NotFoundException;
use OCP\Files\SimpleFS\ISimpleFolder;
use OCP\IConfig;
-use OCP\ILogger;
use OCP\Migration\IOutput;
use OCP\Migration\IRepairStep;
+use Psr\Log\LoggerInterface;
use RuntimeException;
/**
/** @var IAppData */
private $appData;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
- public function __construct(IConfig $config, IAppData $appData, ILogger $logger) {
+ public function __construct(IConfig $config, IAppData $appData, LoggerInterface $logger) {
$this->config = $config;
$this->appData = $appData;
$this->logger = $logger;
} catch (NotFoundException $e) {
return;
} catch (RuntimeException $e) {
- $this->logger->logException($e, ['message' => 'Failed to fetch directory listing in CleanupCardDAVPhotoCache']);
+ $this->logger->error('Failed to fetch directory listing in CleanupCardDAVPhotoCache', ['exception' => $e]);
return;
}
/** @var ISimpleFolder $folder */
$folder->getFile('photo.')->delete();
} catch (\Exception $e) {
- $this->logger->logException($e);
+ $this->logger->error($e->getMessage(), ['exception' => $e]);
$output->warning('Could not delete file "dav-photocache/' . $folder->getName() . '/photo."');
}
}
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
-use OCP\ILogger;
use OCP\IUserManager;
+use Psr\Log\LoggerInterface;
class CleanPreviewsBackgroundJob extends QueuedJob {
/** @var IRootFolder */
private $rootFolder;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var IJobList */
private $jobList;
/**
* CleanPreviewsBackgroundJob constructor.
- *
- * @param IRootFolder $rootFolder
- * @param ILogger $logger
- * @param IJobList $jobList
- * @param ITimeFactory $timeFactory
- * @param IUserManager $userManager
*/
public function __construct(IRootFolder $rootFolder,
- ILogger $logger,
+ LoggerInterface $logger,
IJobList $jobList,
ITimeFactory $timeFactory,
IUserManager $userManager) {
*/
namespace OC\Route;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class CachingRouter extends Router {
/**
/**
* @param \OCP\ICache $cache
- * @param ILogger $logger
*/
- public function __construct($cache, ILogger $logger) {
+ public function __construct($cache, LoggerInterface $logger) {
$this->cache = $cache;
parent::__construct($logger);
}
use OC\AppFramework\Routing\RouteParser;
use OCP\AppFramework\App;
-use OCP\ILogger;
use OCP\Route\IRouter;
use OCP\Util;
+use Psr\Log\LoggerInterface;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\Exception\RouteNotFoundException;
use Symfony\Component\Routing\Generator\UrlGenerator;
protected $loaded = false;
/** @var array */
protected $loadedApps = [];
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var RequestContext */
protected $context;
- /**
- * @param ILogger $logger
- */
- public function __construct(ILogger $logger) {
+ public function __construct(LoggerInterface $logger) {
$this->logger = $logger;
$baseUrl = \OC::$WEBROOT;
if (!(\OC::$server->getConfig()->getSystemValue('htaccess.IgnoreFrontController', false) === true || getenv('front_controller_active') === 'true')) {
try {
return $this->getGenerator()->generate($name, $parameters, $referenceType);
} catch (RouteNotFoundException $e) {
- $this->logger->logException($e, ['level' => ILogger::INFO]);
+ $this->logger->info($e->getMessage(), ['exception' => $e]);
return '';
}
}
namespace OC\Search;
use InvalidArgumentException;
-use OC\AppFramework\Bootstrap\Coordinator;
use OCP\AppFramework\QueryException;
-use OCP\ILogger;
use OCP\IServerContainer;
use OCP\IUser;
use OCP\Search\IProvider;
use OCP\Search\ISearchQuery;
use OCP\Search\SearchResult;
+use OC\AppFramework\Bootstrap\Coordinator;
+use Psr\Log\LoggerInterface;
use function array_map;
/**
/** @var IServerContainer */
private $container;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
public function __construct(Coordinator $bootstrapCoordinator,
IServerContainer $container,
- ILogger $logger) {
+ LoggerInterface $logger) {
$this->container = $container;
$this->logger = $logger;
$this->bootstrapCoordinator = $bootstrapCoordinator;
$this->providers[$provider->getId()] = $provider;
} catch (QueryException $e) {
// Log an continue. We can be fault tolerant here.
- $this->logger->logException($e, [
- 'message' => 'Could not load search provider dynamically: ' . $e->getMessage(),
- 'level' => ILogger::ERROR,
+ $this->logger->error('Could not load search provider dynamically: ' . $e->getMessage(), [
+ 'exception' => $e,
'app' => $registration->getAppId(),
]);
}
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\IConfig;
use OCP\IDBConnection;
-use OCP\ILogger;
use OCP\Security\Bruteforce\MaxDelayReached;
+use Psr\Log\LoggerInterface;
/**
* Class Throttler implements the bruteforce protection for security actions in
private $db;
/** @var ITimeFactory */
private $timeFactory;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var IConfig */
private $config;
/** @var bool */
private $hasAttemptsDeleted = false;
- /**
- * @param IDBConnection $db
- * @param ITimeFactory $timeFactory
- * @param ILogger $logger
- * @param IConfig $config
- */
public function __construct(IDBConnection $db,
ITimeFactory $timeFactory,
- ILogger $logger,
+ LoggerInterface $logger,
IConfig $config) {
$this->db = $db;
$this->timeFactory = $timeFactory;
use OCP\ICertificate;
use OCP\ICertificateManager;
use OCP\IConfig;
-use OCP\ILogger;
use OCP\Security\ISecureRandom;
+use Psr\Log\LoggerInterface;
/**
* Manage trusted certificates for users
*/
protected $config;
- /**
- * @var ILogger
- */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var ISecureRandom */
protected $random;
private ?string $bundlePath = null;
- /**
- * @param \OC\Files\View $view relative to data/
- * @param IConfig $config
- * @param ILogger $logger
- * @param ISecureRandom $random
- */
public function __construct(\OC\Files\View $view,
IConfig $config,
- ILogger $logger,
+ LoggerInterface $logger,
ISecureRandom $random) {
$this->view = $view;
$this->config = $config;
$defaultCertificates = file_get_contents(\OC::$SERVERROOT . '/resources/config/ca-bundle.crt');
if (strlen($defaultCertificates) < 1024) { // sanity check to verify that we have some content for our bundle
// log as exception so we have a stacktrace
- $this->logger->logException(new \Exception('Shipped ca-bundle is empty, refusing to create certificate bundle'));
+ $e = new \Exception('Shipped ca-bundle is empty, refusing to create certificate bundle');
+ $this->logger->error($e->getMessage(), ['exception' => $e]);
return;
}
use OC\Files\AppData\Factory;
use OCP\Files\IAppData;
use OCP\IConfig;
-use OCP\ILogger;
use OCP\IUser;
use OCP\Security\ICrypto;
+use Psr\Log\LoggerInterface;
class Manager {
/** @var IAppData */
private $crypto;
/** @var IConfig */
private $config;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
public function __construct(Factory $appDataFactory,
ICrypto $crypto,
IConfig $config,
- ILogger $logger
+ LoggerInterface $logger
) {
$this->appData = $appDataFactory->get('identityproof');
$this->crypto = $crypto;
private function registerDeprecatedAlias(string $alias, string $target) {
$this->registerService($alias, function (ContainerInterface $container) use ($target, $alias) {
try {
- /** @var ILogger $logger */
- $logger = $container->get(ILogger::class);
+ /** @var LoggerInterface $logger */
+ $logger = $container->get(LoggerInterface::class);
$logger->debug('The requested alias "' . $alias . '" is deprecated. Please request "' . $target . '" directly. This alias will be removed in a future Nextcloud version.', ['app' => 'serverDI']);
} catch (ContainerExceptionInterface $e) {
// Could not get logger. Continue
use OCP\IConfig;
use OCP\IGroupManager;
use OCP\IL10N;
-use OCP\ILogger;
use OCP\IURLGenerator;
use OCP\IUser;
use OCP\IUserManager;
use OCP\Share\IProviderFactory;
use OCP\Share\IShare;
use OCP\Share\IShareProvider;
+use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\GenericEvent;
/** @var IProviderFactory */
private $factory;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var IConfig */
private $config;
/** @var ISecureRandom */
private $knownUserService;
public function __construct(
- ILogger $logger,
+ LoggerInterface $logger,
IConfig $config,
ISecureRandom $secureRandom,
IHasher $hasher,
return;
}
} catch (\Exception $e) {
- $this->logger->logException($e, ['message' => 'Share notification mail could not be sent']);
+ $this->logger->error('Share notification mail could not be sent', ['exception' => $e]);
}
}
*/
namespace OC\Template;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class CSSResourceLocator extends ResourceLocator {
protected $scssCacher;
/**
- * @param ILogger $logger
* @param string $theme
* @param array $core_map
* @param array $party_map
* @param SCSSCacher $scssCacher
*/
- public function __construct(ILogger $logger, $theme, $core_map, $party_map, $scssCacher) {
+ public function __construct(LoggerInterface $logger, $theme, $core_map, $party_map, $scssCacher) {
$this->scssCacher = $scssCacher;
parent::__construct($logger, $theme, $core_map, $party_map);
use OCP\Files\NotFoundException;
use OCP\Files\SimpleFS\ISimpleFile;
use OCP\Files\SimpleFS\ISimpleFolder;
-use OCP\ILogger;
use OCP\IURLGenerator;
+use Psr\Log\LoggerInterface;
class IconsCacher {
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var IAppData */
protected $appData;
private $cachedList;
/**
- * @param ILogger $logger
- * @param Factory $appDataFactory
- * @param IURLGenerator $urlGenerator
- * @param ITimeFactory $timeFactory
* @throws \OCP\Files\NotPermittedException
*/
- public function __construct(ILogger $logger,
+ public function __construct(LoggerInterface $logger,
Factory $appDataFactory,
IURLGenerator $urlGenerator,
ITimeFactory $timeFactory) {
use OCP\Files\SimpleFS\ISimpleFolder;
use OCP\ICache;
use OCP\ICacheFactory;
-use OCP\ILogger;
use OCP\IURLGenerator;
+use Psr\Log\LoggerInterface;
class JSCombiner {
/** @var SystemConfig */
protected $config;
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var ICacheFactory */
private $cacheFactory;
- /**
- * @param IAppData $appData
- * @param IURLGenerator $urlGenerator
- * @param ICacheFactory $cacheFactory
- * @param SystemConfig $config
- * @param ILogger $logger
- */
public function __construct(IAppData $appData,
IURLGenerator $urlGenerator,
ICacheFactory $cacheFactory,
SystemConfig $config,
- ILogger $logger) {
+ LoggerInterface $logger) {
$this->appData = $appData;
$this->urlGenerator = $urlGenerator;
$this->cacheFactory = $cacheFactory;
*/
namespace OC\Template;
+use Psr\Log\LoggerInterface;
+
class JSResourceLocator extends ResourceLocator {
/** @var JSCombiner */
protected $jsCombiner;
- public function __construct(\OCP\ILogger $logger, $theme, array $core_map, array $party_map, JSCombiner $JSCombiner) {
+ public function __construct(LoggerInterface $logger, $theme, array $core_map, array $party_map, JSCombiner $JSCombiner) {
parent::__construct($logger, $theme, $core_map, $party_map);
$this->jsCombiner = $JSCombiner;
*/
namespace OC\Template;
+use Psr\Log\LoggerInterface;
+
abstract class ResourceLocator {
protected $theme;
protected $resources = [];
- /** @var \OCP\ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/**
- * @param \OCP\ILogger $logger
* @param string $theme
* @param array $core_map
* @param array $party_map
*/
- public function __construct(\OCP\ILogger $logger, $theme, $core_map, $party_map) {
+ public function __construct(LoggerInterface $logger, $theme, $core_map, $party_map) {
$this->logger = $logger;
$this->theme = $theme;
$this->mapping = $core_map + $party_map;
use OCP\ICache;
use OCP\ICacheFactory;
use OCP\IConfig;
-use OCP\ILogger;
use OCP\IMemcache;
use OCP\IURLGenerator;
+use Psr\Log\LoggerInterface;
use ScssPhp\ScssPhp\Compiler;
use ScssPhp\ScssPhp\OutputStyle;
class SCSSCacher {
- /** @var ILogger */
- protected $logger;
+ protected LoggerInterface $logger;
/** @var IAppData */
protected $appData;
private $appConfig;
/**
- * @param ILogger $logger
- * @param Factory $appDataFactory
- * @param IURLGenerator $urlGenerator
- * @param IConfig $config
- * @param \OC_Defaults $defaults
* @param string $serverRoot
- * @param ICacheFactory $cacheFactory
- * @param IconsCacher $iconsCacher
- * @param ITimeFactory $timeFactory
*/
- public function __construct(ILogger $logger,
+ public function __construct(LoggerInterface $logger,
Factory $appDataFactory,
IURLGenerator $urlGenerator,
IConfig $config,
'@import "functions.scss";' .
'@import "' . $fileNameSCSS . '";');
} catch (\Exception $e) {
- $this->logger->logException($e, ['app' => 'scss_cacher']);
+ $this->logger->error($e->getMessage(), ['app' => 'scss_cacher', 'exception' => $e]);
return false;
}
try {
$file->delete();
} catch (NotPermittedException $e) {
- $this->logger->logException($e, ['message' => 'SCSSCacher::resetCache unable to delete file: ' . $file->getName(), 'app' => 'scss_cacher']);
+ $this->logger->error('SCSSCacher::resetCache unable to delete file: ' . $file->getName(), ['exception' => $e, 'app' => 'scss_cacher']);
}
}
}
$scss->compile($variables);
$this->injectedVariables = $variables;
} catch (\Exception $e) {
- $this->logger->logException($e, ['app' => 'scss_cacher']);
+ $this->logger->error($e->getMessage(), ['exception' => $e, 'app' => 'scss_cacher']);
}
return $variables;
use OCP\AppFramework\Db\DoesNotExistException;
use OCP\Http\Client\IClientService;
use OCP\Http\Client\IResponse;
-use OCP\ILogger;
+use Psr\Log\LoggerInterface;
class ChangesCheck {
/** @var IClientService */
protected $clientService;
/** @var ChangesMapper */
private $mapper;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
public const RESPONSE_NO_CONTENT = 0;
public const RESPONSE_USE_CACHE = 1;
public const RESPONSE_HAS_CONTENT = 2;
- public function __construct(IClientService $clientService, ChangesMapper $mapper, ILogger $logger) {
+ public function __construct(IClientService $clientService, ChangesMapper $mapper, LoggerInterface $logger) {
$this->clientService = $clientService;
$this->mapper = $mapper;
$this->logger = $logger;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\NotPermittedException;
use OCP\IConfig;
-use OCP\ILogger;
use OCP\IRequest;
use OCP\ISession;
use OCP\IUser;
use OCP\Session\Exceptions\SessionNotAvailableException;
use OCP\User\Events\PostLoginEvent;
use OCP\Util;
+use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\GenericEvent;
/**
/** @var ILockdownManager */
private $lockdownManager;
- /** @var ILogger */
- private $logger;
+ private LoggerInterface $logger;
/** @var IEventDispatcher */
private $dispatcher;
- /**
- * @param Manager $manager
- * @param ISession $session
- * @param ITimeFactory $timeFactory
- * @param IProvider|null $tokenProvider
- * @param IConfig $config
- * @param ISecureRandom $random
- * @param ILockdownManager $lockdownManager
- * @param ILogger $logger
- */
public function __construct(Manager $manager,
ISession $session,
ITimeFactory $timeFactory,
IConfig $config,
ISecureRandom $random,
ILockdownManager $lockdownManager,
- ILogger $logger,
+ LoggerInterface $logger,
IEventDispatcher $dispatcher
) {
$this->manager = $manager;
} catch (ExpiredTokenException $e) {
throw $e;
} catch (InvalidTokenException $ex) {
- $this->logger->logException($ex, [
- 'level' => ILogger::DEBUG,
- 'message' => 'Token is not valid: ' . $ex->getMessage(),
+ $this->logger->debug('Token is not valid: ' . $ex->getMessage(), [
+ 'exception' => $ex,
]);
return false;
}
} catch (SessionNotAvailableException $ex) {
return false;
} catch (InvalidTokenException $ex) {
- \OC::$server->getLogger()->warning('Renewing session token failed', ['app' => 'core']);
+ $this->logger->warning('Renewing session token failed', ['app' => 'core']);
return false;
}
projects / nextcloud-server.git / commitdiff