Merge pull request #9308 from nextcloud/proper-ocp-constants

Move log constants to ILogger

apps/dav/lib/Connector/Sabre/ExceptionLoggerPlugin.php

 	 */
 	public function logException(\Exception $ex) {
 		$exceptionClass = get_class($ex);
-		$level = \OCP\Util::FATAL;
+		$level = ILogger::FATAL;
 		if (isset($this->nonFatalExceptions[$exceptionClass]) ||
 			(
 				$exceptionClass === ServiceUnavailable::class &&
 				$ex->getMessage() === 'System in maintenance mode.'
 			)
 		) {
-			$level = \OCP\Util::DEBUG;
+			$level = ILogger::DEBUG;
 		}
 
 		$this->logger->logException($ex, [

apps/encryption/lib/KeyManager.php

 		} catch (\Exception $e) {
 			$this->log->logException($e, [
 				'message' => 'Could not decrypt the private key from user "' . $uid . '"" during login. Assume password change on the user back-end.',
-				'level' => \OCP\Util::WARN,
+				'level' => ILogger::WARN,
 				'app' => 'encryption',
 			]);
 			return false;

apps/federatedfilesharing/lib/Controller/MountPublicLinkController.php

 use OCP\Files\StorageInvalidException;
 use OCP\Http\Client\IClientService;
 use OCP\IL10N;
+use OCP\ILogger;
 use OCP\IRequest;
 use OCP\ISession;
 use OCP\IUserSession;
 			$this->federatedShareProvider->create($share);
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::WARN,
+				'level' => ILogger::WARN,
 				'app' => 'federatedfilesharing',
 			]);
 			return new JSONResponse(['message' => $e->getMessage()], Http::STATUS_BAD_REQUEST);

apps/federatedfilesharing/lib/Controller/RequestHandlerController.php

 			} catch (\Exception $e) {
 				$this->logger->logException($e, [
 					'message' => 'Server can not add remote share.',
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'files_sharing'
 				]);
 				throw new OCSException('internal server error, was not able to add share from ' . $remote, 500);

apps/federatedfilesharing/lib/FederatedShareProvider.php

 		} catch (\Exception $e) {
 			$this->logger->logException($e, [
 				'message' => 'Failed to notify remote server of federated share, removing share.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'federatedfilesharing',
 			]);
 			$failure = true;

apps/federation/lib/BackgroundJob/GetSharedSecret.php

 			$status = -1; // There is no status code if we could not connect
 			$this->logger->logException($e, [
 				'message' => 'Could not connect to ' . $target,
-				'level' => \OCP\Util::INFO,
+				'level' => ILogger::INFO,
 				'app' => 'federation',
 			]);
 		} catch (RingException $e) {
 			$status = -1; // There is no status code if we could not connect
 			$this->logger->logException($e, [
 				'message' => 'Could not connect to ' . $target,
-				'level' => \OCP\Util::INFO,
+				'level' => ILogger::INFO,
 				'app' => 'federation',
 			]);
 		} catch (\Exception $e) {

apps/federation/lib/Middleware/AddServerMiddleware.php

 			throw $exception;
 		}
 		$this->logger->logException($exception, [
-			'level' => \OCP\Util::ERROR,
+			'level' => ILogger::ERROR,
 			'app' => $this->appName,
 		]);
 		if ($exception instanceof HintException) {

apps/federation/lib/SyncJob.php

 			if ($ex instanceof \Exception) {
 				$this->logger->logException($ex, [
 					'message' => "Error while syncing $url.",
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'fed-sync',
 				]);
 			}

apps/federation/lib/TrustedServers.php

 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'No Nextcloud server.',
-				'level' => \OCP\Util::DEBUG,
+				'level' => ILogger::DEBUG,
 				'app' => 'federation',
 			]);
 			return false;

apps/files_external/lib/Lib/Storage/SMB.php

 use OCP\Files\Notify\IRenameChange;
 use OCP\Files\Storage\INotifyStorage;
 use OCP\Files\StorageNotAvailableException;
+use OCP\ILogger;
 use OCP\Util;
 
 class SMB extends Common implements INotifyStorage {
 			$this->remove($target);
 			$result = $this->share->rename($absoluteSource, $absoluteTarget);
 		} catch (\Exception $e) {
-			\OC::$server->getLogger()->logException($e, ['level' => Util::WARN]);
+			\OC::$server->getLogger()->logException($e, ['level' => ILogger::WARN]);
 			return false;
 		}
 		unset($this->statCache[$absoluteSource], $this->statCache[$absoluteTarget]);

apps/files_external/lib/Lib/Storage/Swift.php

 use Icewind\Streams\IteratorDirectory;
 use OC\Files\ObjectStore\SwiftFactory;
 use OCP\Files\StorageBadConfigException;
+use OCP\ILogger;
 use OpenStack\Common\Error\BadResponseError;
 use OpenStack\ObjectStore\v1\Models\StorageObject;
 
 			// Expected response is "404 Not Found", so only log if it isn't
 			if ($e->getResponse()->getStatusCode() !== 404) {
 				\OC::$server->getLogger()->logException($e, [
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'files_external',
 				]);
 			}
 			$this->objectCache->remove($path);
 		} catch (BadResponseError $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return false;
 			$this->objectCache->remove($path . '/');
 		} catch (BadResponseError $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return false;
 			return IteratorDirectory::wrap($files);
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return false;
 			}
 		} catch (BadResponseError $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return false;
 		} catch (BadResponseError $e) {
 			if ($e->getResponse()->getStatusCode() !== 404) {
 				\OC::$server->getLogger()->logException($e, [
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'files_external',
 				]);
 				throw $e;
 					return $this->objectStore->readObject($path);
 				} catch (BadResponseError $e) {
 					\OC::$server->getLogger()->logException($e, [
-						'level' => \OCP\Util::ERROR,
+						'level' => ILogger::ERROR,
 						'app' => 'files_external',
 					]);
 					return false;
 				$this->objectCache->remove($path2 . '/');
 			} catch (BadResponseError $e) {
 				\OC::$server->getLogger()->logException($e, [
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'files_external',
 				]);
 				return false;
 				$this->objectCache->remove($path2 . '/');
 			} catch (BadResponseError $e) {
 				\OC::$server->getLogger()->logException($e, [
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'files_external',
 				]);
 				return false;

apps/files_external/lib/Service/LegacyStoragesService.php

 namespace OCA\Files_External\Service;
 
 use OCA\Files_External\Lib\StorageConfig;
+use OCP\ILogger;
 
 /**
  * Read mount config from legacy mount.json
 						// don't die if a storage backend doesn't exist
 						\OC::$server->getLogger()->logException($e, [
 							'message' => 'Could not load storage.',
-							'level' => \OCP\Util::ERROR,
+							'level' => ILogger::ERROR,
 							'app' => 'files_external',
 						]);
 					}

apps/files_external/lib/Service/StoragesService.php

 use \OCA\Files_External\Lib\Auth\AuthMechanism;
 use OCP\Files\Config\IUserMountCache;
 use \OCP\Files\StorageNotAvailableException;
+use OCP\ILogger;
 
 /**
  * Service class to manage external storages
 			// don't die if a storage backend doesn't exist
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'Could not load storage.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return null;
 		} catch (\InvalidArgumentException $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'Could not load storage.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 			return null;
 			// be instantiated or whenever $user vars where used, in which case
 			// the storage id could not be computed
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'files_external',
 			]);
 		}

apps/files_trashbin/ajax/delete.php

  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
  */
+
+use OCP\ILogger;
+
 \OC_JSON::checkLoggedIn();
 \OC_JSON::callCheck();
 \OC::$server->getSession()->close();
 	OCA\Files_Trashbin\Trashbin::delete($filename, \OCP\User::getUser(), $timestamp);
 	if (OCA\Files_Trashbin\Trashbin::file_exists($filename, $timestamp)) {
 		$error[] = $filename;
-		\OCP\Util::writeLog('trashbin','can\'t delete ' . $filename . ' permanently.', \OCP\Util::ERROR);
+		\OCP\Util::writeLog('trashbin','can\'t delete ' . $filename . ' permanently.', ILogger::ERROR);
 	}
 	// only list deleted files if not deleting everything
 	else if (!$deleteAll) {

apps/files_trashbin/ajax/undelete.php

  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
  */
+
+use OCP\ILogger;
+
 \OC_JSON::checkLoggedIn();
 \OC_JSON::callCheck();
 \OC::$server->getSession()->close();
 
 	if ( !OCA\Files_Trashbin\Trashbin::restore($path, $filename, $timestamp) ) {
 		$error[] = $filename;
-		\OCP\Util::writeLog('trashbin', 'can\'t restore ' . $filename, \OCP\Util::ERROR);
+		\OCP\Util::writeLog('trashbin', 'can\'t restore ' . $filename, ILogger::ERROR);
 	} else {
 		$success[$i]['filename'] = $file;
 		$success[$i]['timestamp'] = $timestamp;

apps/files_trashbin/lib/Storage.php

 			// do nothing, in this case we just disable the trashbin and continue
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'Trashbin storage could not check if a file was moved out of a shared folder.',
-				'level' => \OCP\Util::DEBUG,
+				'level' => ILogger::DEBUG,
 				'app' => 'files_trashbin',
 			]);
 		}

apps/provisioning_api/lib/Controller/UsersController.php

 				} catch (\Exception $e) {
 					$this->logger->logException($e, [
 						'message' => "Can't send new user mail to $email",
-						'level' => \OCP\Util::ERROR,
+						'level' => ILogger::ERROR,
 						'app' => 'ocs_api',
 					]);
 					throw new OCSException('Unable to send the invitation mail', 109);
 		} catch (HintException $e ) {
 			$this->logger->logException($e, [
 				'message' => 'Failed addUser attempt with hint exception.',
-				'level' => \OCP\Util::WARN,
+				'level' => ILogger::WARN,
 				'app' => 'ocs_api',
 			]);
 			throw new OCSException($e->getHint(), 107);
 		} catch (\Exception $e) {
 			$this->logger->logException($e, [
 				'message' => 'Failed addUser attempt with exception.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'ocs_api',
 			]);
 			throw new OCSException('Bad request', 101);
 		} catch(\Exception $e) {
 			$this->logger->logException($e, [
 				'message' => "Can't send new user mail to $email",
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'settings',
 			]);
 			throw new OCSException('Sending email failed', 102);

apps/provisioning_api/tests/Controller/UsersControllerTest.php

 			->method('logException')
 			->with($exception, [
 				'message' => 'Failed addUser attempt with exception.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'ocs_api',
 			]);
 		$loggedInUser = $this->getMockBuilder(IUser::class)

apps/sharebymail/lib/ShareByMailProvider.php

 		} catch (HintException $hintException) {
 			$this->logger->logException($hintException, [
 				'message' => 'Failed to send share by mail.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'sharebymail',
 			]);
 			$this->removeShareFromTable($shareId);
 		} catch (\Exception $e) {
 			$this->logger->logException($e, [
 				'message' => 'Failed to send share by mail.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'sharebymail',
 			]);
 			$this->removeShareFromTable($shareId);

apps/user_ldap/lib/Access.php

 use OCA\User_LDAP\Mapping\AbstractMapping;
 use OC\ServerNotAvailableException;
 use OCP\IConfig;
+use OCP\ILogger;
 use OCP\IUserManager;
 use OCP\Util;
 
 		if(!$this->checkConnection()) {
 			\OCP\Util::writeLog('user_ldap',
 				'No LDAP Connector assigned, access impossible for readAttribute.',
-				\OCP\Util::WARN);
+				ILogger::WARN);
 			return false;
 		}
 		$cr = $this->connection->getConnectionResource();
 		if(!$this->ldap->isResource($cr)) {
 			//LDAP not available
-			\OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', ILogger::DEBUG);
 			return false;
 		}
 		//Cancel possibly running Paged Results operation, otherwise we run in
 			}
 		} while($isRangeRequest);
 
-		\OCP\Util::writeLog('user_ldap', 'Requested attribute '.$attr.' not found for '.$dn, \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'Requested attribute '.$attr.' not found for '.$dn, ILogger::DEBUG);
 		return false;
 	}
 
 		if (!$this->ldap->isResource($rr)) {
 			if ($attribute !== '') {
 				//do not throw this message on userExists check, irritates
-				\OCP\Util::writeLog('user_ldap', 'readAttribute failed for DN ' . $dn, \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('user_ldap', 'readAttribute failed for DN ' . $dn, ILogger::DEBUG);
 			}
 			//in case an error occurs , e.g. object does not exist
 			return false;
 		}
 		if ($attribute === '' && ($filter === 'objectclass=*' || $this->invokeLDAPMethod('countEntries', $cr, $rr) === 1)) {
-			\OCP\Util::writeLog('user_ldap', 'readAttribute: ' . $dn . ' found', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'readAttribute: ' . $dn . ' found', ILogger::DEBUG);
 			return true;
 		}
 		$er = $this->invokeLDAPMethod('firstEntry', $cr, $rr);
 		$cr = $this->connection->getConnectionResource();
 		if(!$this->ldap->isResource($cr)) {
 			//LDAP not available
-			\OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', ILogger::DEBUG);
 			return false;
 		}
 		try {
 			}
 		} else {
 			//If the UUID can't be detected something is foul.
-			\OCP\Util::writeLog('user_ldap', 'Cannot determine UUID for '.$fdn.'. Skipping.', \OCP\Util::INFO);
+			\OCP\Util::writeLog('user_ldap', 'Cannot determine UUID for '.$fdn.'. Skipping.', ILogger::INFO);
 			return false;
 		}
 
 		if(is_null($ldapName)) {
 			$ldapName = $this->readAttribute($fdn, $nameAttribute, $filter);
 			if(!isset($ldapName[0]) && empty($ldapName[0])) {
-				\OCP\Util::writeLog('user_ldap', 'No or empty name for '.$fdn.' with filter '.$filter.'.', \OCP\Util::INFO);
+				\OCP\Util::writeLog('user_ldap', 'No or empty name for '.$fdn.' with filter '.$filter.'.', ILogger::INFO);
 				return false;
 			}
 			$ldapName = $ldapName[0];
 			} catch (\InvalidArgumentException $e) {
 				\OC::$server->getLogger()->logException($e, [
 					'app' => 'user_ldap',
-					'level' => Util::WARN,
+					'level' => ILogger::WARN,
 				]);
 				// we don't attempt to set a username here. We can go for
 				// for an alternative 4 digit random number as we would append
 		}
 
 		//if everything else did not help..
-		\OCP\Util::writeLog('user_ldap', 'Could not create unique name for '.$fdn.'.', \OCP\Util::INFO);
+		\OCP\Util::writeLog('user_ldap', 'Could not create unique name for '.$fdn.'.', ILogger::INFO);
 		return false;
 	}
 
 			 * Maybe implement exponential backoff?
 			 * This was enough to get solr indexer working which has large delays between LDAP fetches.
 			 */
-			\OCP\Util::writeLog('user_ldap', "Connection lost on $command, attempting to reestablish.", \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', "Connection lost on $command, attempting to reestablish.", ILogger::DEBUG);
 			$this->connection->resetConnectionResource();
 			$cr = $this->connection->getConnectionResource();
 
 			if(!$this->ldap->isResource($cr)) {
 				// Seems like we didn't find any resource.
-				\OCP\Util::writeLog('user_ldap', "Could not $command, because resource is missing.", \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('user_ldap', "Could not $command, because resource is missing.", ILogger::DEBUG);
 				throw $e;
 			}
 
 		if(!$this->ldap->isResource($cr)) {
 			// Seems like we didn't find any resource.
 			// Return an empty array just like before.
-			\OCP\Util::writeLog('user_ldap', 'Could not search, because resource is missing.', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'Could not search, because resource is missing.', ILogger::DEBUG);
 			return false;
 		}
 
 		// cannot use $cr anymore, might have changed in the previous call!
 		$error = $this->ldap->errno($this->connection->getConnectionResource());
 		if(!is_array($sr) || $error !== 0) {
-			\OCP\Util::writeLog('user_ldap', 'Attempt for Paging?  '.print_r($pagedSearchOK, true), \OCP\Util::ERROR);
+			\OCP\Util::writeLog('user_ldap', 'Attempt for Paging?  '.print_r($pagedSearchOK, true), ILogger::ERROR);
 			return false;
 		}
 
 	 * @throws ServerNotAvailableException
 	 */
 	private function count($filter, $base, $attr = null, $limit = null, $offset = null, $skipHandling = false) {
-		\OCP\Util::writeLog('user_ldap', 'Count filter:  '.print_r($filter, true), \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'Count filter:  '.print_r($filter, true), ILogger::DEBUG);
 
 		$limitPerPage = (int)$this->connection->ldapPagingSize;
 		if(!is_null($limit) && $limit < $limitPerPage && $limit > 0) {
 				\OCP\Util::writeLog(
 					'user_ldap',
 					'Creating advanced filter for search failed, falling back to simple method.',
-					\OCP\Util::INFO
+					ILogger::INFO
 				);
 			}
 		}
 
 			$value = $this->readAttribute($dn, $attribute);
 			if(is_array($value) && isset($value[0]) && !empty($value[0])) {
-				\OCP\Util::writeLog('user_ldap',
-									'Setting '.$attribute.' as '.$uuidAttr,
-									\OCP\Util::DEBUG);
+				\OCP\Util::writeLog(
+					'user_ldap',
+					'Setting '.$attribute.' as '.$uuidAttr,
+					ILogger::DEBUG
+				);
 				$this->connection->$uuidAttr = $attribute;
 				return true;
 			}
 		}
-		\OCP\Util::writeLog('user_ldap',
-							'Could not autodetect the UUID attribute',
-							\OCP\Util::ERROR);
+		\OCP\Util::writeLog(
+			'user_ldap',
+			'Could not autodetect the UUID attribute',
+			ILogger::ERROR
+		);
 
 		return false;
 	}
 			\OCP\Util::writeLog('user_ldap',
 				'initializing paged search for  Filter '.$filter.' base '.print_r($bases, true)
 				.' attr '.print_r($attr, true). ' limit ' .$limit.' offset '.$offset,
-				\OCP\Util::DEBUG);
+				ILogger::DEBUG);
 			//get the cookie from the search for the previous search, required by LDAP
 			foreach($bases as $base) {
 
 					if(!$pagedSearchOK) {
 						return false;
 					}
-					\OCP\Util::writeLog('user_ldap', 'Ready for a paged search', \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('user_ldap', 'Ready for a paged search', ILogger::DEBUG);
 				} else {
 					$e = new \Exception('No paged search possible, Limit '.$limit.' Offset '.$offset);
-					\OC::$server->getLogger()->logException($e, ['level' => Util::DEBUG]);
+					\OC::$server->getLogger()->logException($e, ['level' => ILogger::DEBUG]);
 				}
 
 			}

apps/user_ldap/lib/Connection.php

 namespace OCA\User_LDAP;
 
 use OC\ServerNotAvailableException;
+use OCP\ILogger;
 
 /**
  * magic properties (incomplete)
 			$this->establishConnection();
 		}
 		if(is_null($this->ldapConnectionRes)) {
-			\OCP\Util::writeLog('user_ldap', 'No LDAP Connection to server ' . $this->configuration->ldapHost, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('user_ldap', 'No LDAP Connection to server ' . $this->configuration->ldapHost, ILogger::ERROR);
 			throw new ServerNotAvailableException('Connection to LDAP server could not be established');
 		}
 		return $this->ldapConnectionRes;
 					\OCP\Util::writeLog('user_ldap',
 										'Illegal value for the '.
 										$effectiveSetting.', '.'reset to '.
-										'autodetect.', \OCP\Util::INFO);
+										'autodetect.', ILogger::INFO);
 				}
 
 			}
 		if((stripos($this->configuration->ldapHost, 'ldaps://') === 0)
 			&& $this->configuration->ldapTLS) {
 			$this->configuration->ldapTLS = false;
-			\OCP\Util::writeLog('user_ldap',
-								'LDAPS (already using secure connection) and '.
-								'TLS do not work together. Switched off TLS.',
-								\OCP\Util::INFO);
+			\OCP\Util::writeLog(
+				'user_ldap',
+				'LDAPS (already using secure connection) and TLS do not work together. Switched off TLS.',
+				ILogger::INFO
+			);
 		}
 	}
 
 						break;
 				}
 				$configurationOK = false;
-				\OCP\Util::writeLog('user_ldap',
-									$errorStr.'No '.$subj.' given!',
-									\OCP\Util::WARN);
+				\OCP\Util::writeLog(
+					'user_ldap',
+					$errorStr.'No '.$subj.' given!',
+					ILogger::WARN
+				);
 			}
 		}
 
 			($agent === ''  && $pwd !== '')
 			|| ($agent !== '' && $pwd === '')
 		) {
-			\OCP\Util::writeLog('user_ldap',
-								$errorStr.'either no password is given for the '.
-								'user agent or a password is given, but not an '.
-								'LDAP agent.',
-				\OCP\Util::WARN);
+			\OCP\Util::writeLog(
+				'user_ldap',
+				$errorStr.'either no password is given for the user ' .
+					'agent or a password is given, but not an LDAP agent.',
+				ILogger::WARN);
 			$configurationOK = false;
 		}
 
 		$baseGroups = $this->configuration->ldapBaseGroups;
 
 		if(empty($base) && empty($baseUsers) && empty($baseGroups)) {
-			\OCP\Util::writeLog('user_ldap',
-								$errorStr.'Not a single Base DN given.',
-								\OCP\Util::WARN);
+			\OCP\Util::writeLog(
+				'user_ldap',
+				$errorStr.'Not a single Base DN given.',
+				ILogger::WARN
+			);
 			$configurationOK = false;
 		}
 
 		if(mb_strpos($this->configuration->ldapLoginFilter, '%uid', 0, 'UTF-8')
 		   === false) {
-			\OCP\Util::writeLog('user_ldap',
-								$errorStr.'login filter does not contain %uid '.
-								'place holder.',
-								\OCP\Util::WARN);
+			\OCP\Util::writeLog(
+				'user_ldap',
+				$errorStr.'login filter does not contain %uid place holder.',
+				ILogger::WARN
+			);
 			$configurationOK = false;
 		}
 
 			return false;
 		}
 		if(!$this->ignoreValidation && !$this->configured) {
-			\OCP\Util::writeLog('user_ldap',
-								'Configuration is invalid, cannot connect',
-								\OCP\Util::WARN);
+			\OCP\Util::writeLog(
+				'user_ldap',
+				'Configuration is invalid, cannot connect',
+				ILogger::WARN
+			);
 			return false;
 		}
 		if(!$this->ldapConnectionRes) {
 			if(!$this->ldap->areLDAPFunctionsAvailable()) {
 				$phpLDAPinstalled = false;
-				\OCP\Util::writeLog('user_ldap',
-									'function ldap_connect is not available. Make '.
-									'sure that the PHP ldap module is installed.',
-									\OCP\Util::ERROR);
+				\OCP\Util::writeLog(
+					'user_ldap',
+					'function ldap_connect is not available. Make sure that the PHP ldap module is installed.',
+					ILogger::ERROR
+				);
 
 				return false;
 			}
 				if(putenv('LDAPTLS_REQCERT=never')) {
 					\OCP\Util::writeLog('user_ldap',
 						'Turned off SSL certificate validation successfully.',
-						\OCP\Util::DEBUG);
+						ILogger::DEBUG);
 				} else {
-					\OCP\Util::writeLog('user_ldap',
-										'Could not turn off SSL certificate validation.',
-										\OCP\Util::WARN);
+					\OCP\Util::writeLog(
+						'user_ldap',
+						'Could not turn off SSL certificate validation.',
+						ILogger::WARN
+					);
 				}
 			}
 
 
 			\OCP\Util::writeLog('user_ldap',
 				'Bind failed: ' . $errno . ': ' . $this->ldap->error($cr),
-				\OCP\Util::WARN);
+				ILogger::WARN);
 
 			// Set to failure mode, if LDAP error code is not LDAP_SUCCESS or LDAP_INVALID_CREDENTIALS
 			if($errno !== 0x00 && $errno !== 0x31) {

apps/user_ldap/lib/Group_LDAP.php

 
 use OC\Cache\CappedMemoryCache;
 use OCP\GroupInterface;
+use OCP\ILogger;
 
 class Group_LDAP extends BackendUtility implements \OCP\GroupInterface, IGroupLDAP {
 	protected $enabled = false;
 				}
 			} else {
 				\OCP\Util::writeLog('user_ldap', 'No search filter found on member url '.
-					'of group ' . $dnGroup, \OCP\Util::DEBUG);
+					'of group ' . $dnGroup, ILogger::DEBUG);
 			}
 		}
 		return $dynamicMembers;
 					}
 				} else {
 					\OCP\Util::writeLog('user_ldap', 'No search filter found on member url '.
-						'of group ' . print_r($dynamicGroup, true), \OCP\Util::DEBUG);
+						'of group ' . print_r($dynamicGroup, true), ILogger::DEBUG);
 				}
 			}
 		}
 			$result = $this->access->readAttribute($userDN, 'uid');
 			if ($result === false) {
 				\OCP\Util::writeLog('user_ldap', 'No uid attribute found for DN ' . $userDN . ' on '.
-					$this->access->connection->ldapHost, \OCP\Util::DEBUG);
+					$this->access->connection->ldapHost, ILogger::DEBUG);
 			}
 			$uid = $result[0];
 		} else {
 		$cacheKey = 'getGroups-'.$search.'-'.$limit.'-'.$offset;
 
 		//Check cache before driving unnecessary searches
-		\OCP\Util::writeLog('user_ldap', 'getGroups '.$cacheKey, \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'getGroups '.$cacheKey, ILogger::DEBUG);
 		$ldap_groups = $this->access->connection->getFromCache($cacheKey);
 		if(!is_null($ldap_groups)) {
 			return $ldap_groups;
 			$this->access->connection->ldapGroupFilter,
 			$this->access->getFilterPartForGroupSearch($search)
 		));
-		\OCP\Util::writeLog('user_ldap', 'getGroups Filter '.$filter, \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'getGroups Filter '.$filter, ILogger::DEBUG);
 		$ldap_groups = $this->access->fetchListOfGroups($filter,
 				array($this->access->connection->ldapGroupDisplayName, 'dn'),
 				$limit,
 			$chunkLimit = min($pagingSize, $overallLimit - $chunkOffset);
 			$ldapGroups = $this->getGroupsChunk($search, $chunkLimit, $chunkOffset);
 			$nread = count($ldapGroups);
-			\OCP\Util::writeLog('user_ldap', 'getGroups('.$search.'): read '.$nread.' at offset '.$chunkOffset.' (limit: '.$chunkLimit.')', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'getGroups('.$search.'): read '.$nread.' at offset '.$chunkOffset.' (limit: '.$chunkLimit.')', ILogger::DEBUG);
 			if ($nread) {
 				$allGroups = array_merge($allGroups, $ldapGroups);
 				$chunkOffset += $nread;

apps/user_ldap/lib/Jobs/UpdateGroups.php

 use OCA\User_LDAP\Mapping\GroupMapping;
 use OCA\User_LDAP\Mapping\UserMapping;
 use OCA\User_LDAP\User\Manager;
+use OCP\ILogger;
 
 class UpdateGroups extends \OC\BackgroundJob\TimedJob {
 	static private $groupsFromDB;
 	}
 
 	static public function updateGroups() {
-		\OCP\Util::writeLog('user_ldap', 'Run background job "updateGroups"', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'Run background job "updateGroups"', ILogger::DEBUG);
 
 		$knownGroups = array_keys(self::getKnownGroups());
 		$actualGroups = self::getGroupBE()->getGroups();
 		if(empty($actualGroups) && empty($knownGroups)) {
 			\OCP\Util::writeLog('user_ldap',
 				'bgJ "updateGroups" – groups do not seem to be configured properly, aborting.',
-				\OCP\Util::INFO);
+				ILogger::INFO);
 			return;
 		}
 
 		self::handleCreatedGroups(array_diff($actualGroups, $knownGroups));
 		self::handleRemovedGroups(array_diff($knownGroups, $actualGroups));
 
-		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Finished.', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Finished.', ILogger::DEBUG);
 	}
 
 	/**
 	 * @param string[] $groups
 	 */
 	static private function handleKnownGroups($groups) {
-		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Dealing with known Groups.', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Dealing with known Groups.', ILogger::DEBUG);
 		$query = \OC_DB::prepare('
 			UPDATE `*PREFIX*ldap_group_members`
 			SET `owncloudusers` = ?
 				\OCP\Util::emitHook('OC_User', 'post_removeFromGroup', array('uid' => $removedUser, 'gid' => $group));
 				\OCP\Util::writeLog('user_ldap',
 				'bgJ "updateGroups" – "'.$removedUser.'" removed from "'.$group.'".',
-				\OCP\Util::INFO);
+					ILogger::INFO);
 				$hasChanged = true;
 			}
 			foreach(array_diff($actualUsers, $knownUsers) as $addedUser) {
 				\OCP\Util::emitHook('OC_User', 'post_addToGroup', array('uid' => $addedUser, 'gid' => $group));
 				\OCP\Util::writeLog('user_ldap',
 				'bgJ "updateGroups" – "'.$addedUser.'" added to "'.$group.'".',
-				\OCP\Util::INFO);
+					ILogger::INFO);
 				$hasChanged = true;
 			}
 			if($hasChanged) {
 		}
 		\OCP\Util::writeLog('user_ldap',
 			'bgJ "updateGroups" – FINISHED dealing with known Groups.',
-			\OCP\Util::DEBUG);
+			ILogger::DEBUG);
 	}
 
 	/**
 	 * @param string[] $createdGroups
 	 */
 	static private function handleCreatedGroups($createdGroups) {
-		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with created Groups.', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with created Groups.', ILogger::DEBUG);
 		$query = \OC_DB::prepare('
 			INSERT
 			INTO `*PREFIX*ldap_group_members` (`owncloudname`, `owncloudusers`)
 		foreach($createdGroups as $createdGroup) {
 			\OCP\Util::writeLog('user_ldap',
 				'bgJ "updateGroups" – new group "'.$createdGroup.'" found.',
-				\OCP\Util::INFO);
+				ILogger::INFO);
 			$users = serialize(self::getGroupBE()->usersInGroup($createdGroup));
 			$query->execute(array($createdGroup, $users));
 		}
 		\OCP\Util::writeLog('user_ldap',
 			'bgJ "updateGroups" – FINISHED dealing with created Groups.',
-			\OCP\Util::DEBUG);
+			ILogger::DEBUG);
 	}
 
 	/**
 	 * @param string[] $removedGroups
 	 */
 	static private function handleRemovedGroups($removedGroups) {
-		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with removed groups.', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with removed groups.', ILogger::DEBUG);
 		$query = \OC_DB::prepare('
 			DELETE
 			FROM `*PREFIX*ldap_group_members`
 		foreach($removedGroups as $removedGroup) {
 			\OCP\Util::writeLog('user_ldap',
 				'bgJ "updateGroups" – group "'.$removedGroup.'" was removed.',
-				\OCP\Util::INFO);
+				ILogger::INFO);
 			$query->execute(array($removedGroup));
 		}
 		\OCP\Util::writeLog('user_ldap',
 			'bgJ "updateGroups" – FINISHED dealing with removed groups.',
-			\OCP\Util::DEBUG);
+			ILogger::DEBUG);
 	}
 
 	/**

apps/user_ldap/lib/User/User.php

 use OCA\User_LDAP\LogWrapper;
 use OCP\IAvatarManager;
 use OCP\IConfig;
+use OCP\ILogger;
 use OCP\Image;
 use OCP\IUserManager;
 use OCP\Util;
 		INotificationManager $notificationManager) {
 	
 		if ($username === null) {
-			$log->log("uid for '$dn' must not be null!", Util::ERROR);
+			$log->log("uid for '$dn' must not be null!", ILogger::ERROR);
 			throw new \InvalidArgumentException('uid must not be null!');
 		} else if ($username === '') {
-			$log->log("uid for '$dn' must not be an empty string", Util::ERROR);
+			$log->log("uid for '$dn' must not be an empty string", ILogger::ERROR);
 			throw new \InvalidArgumentException('uid must not be an empty string!');
 		}
 
 					if ($this->verifyQuotaValue($aQuota[0])) {
 						$quota = $aQuota[0];
 					} else {
-						$this->log->log('not suitable LDAP quota found for user ' . $this->uid . ': [' . $aQuota[0] . ']', \OCP\Util::WARN);
+						$this->log->log('not suitable LDAP quota found for user ' . $this->uid . ': [' . $aQuota[0] . ']', ILogger::WARN);
 					}
 				}
 			}
 			if ($this->verifyQuotaValue($valueFromLDAP)) {
 				$quota = $valueFromLDAP;
 			} else {
-				$this->log->log('not suitable LDAP quota found for user ' . $this->uid . ': [' . $valueFromLDAP . ']', \OCP\Util::WARN);
+				$this->log->log('not suitable LDAP quota found for user ' . $this->uid . ': [' . $valueFromLDAP . ']', ILogger::WARN);
 			}
 		}
 
 			if($quota !== false) {
 				$targetUser->setQuota($quota);
 			} else {
-				$this->log->log('not suitable default quota found for user ' . $this->uid . ': [' . $defaultQuota . ']', \OCP\Util::WARN);
+				$this->log->log('not suitable default quota found for user ' . $this->uid . ': [' . $defaultQuota . ']', ILogger::WARN);
 			}
 		} else {
-			$this->log->log('trying to set a quota for user ' . $this->uid . ' but the user is missing', \OCP\Util::ERROR);
+			$this->log->log('trying to set a quota for user ' . $this->uid . ' but the user is missing', ILogger::ERROR);
 		}
 	}
 
 	 */
 	private function setOwnCloudAvatar() {
 		if(!$this->image->valid()) {
-			$this->log->log('jpegPhoto data invalid for '.$this->dn, \OCP\Util::ERROR);
+			$this->log->log('jpegPhoto data invalid for '.$this->dn, ILogger::ERROR);
 			return;
 		}
 		//make sure it is a square and not bigger than 128x128
 		$size = min(array($this->image->width(), $this->image->height(), 128));
 		if(!$this->image->centerCrop($size)) {
-			$this->log->log('croping image for avatar failed for '.$this->dn, \OCP\Util::ERROR);
+			$this->log->log('croping image for avatar failed for '.$this->dn, ILogger::ERROR);
 			return;
 		}
 
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'Could not set avatar for ' . $this->dn,
-				'level' => \OCP\Util::INFO,
+				'level' => ILogger::INFO,
 				'app' => 'user_ldap',
 			]);
 		}

apps/user_ldap/lib/User_LDAP.php

 use OCA\User_LDAP\User\OfflineUser;
 use OCA\User_LDAP\User\User;
 use OCP\IConfig;
+use OCP\ILogger;
 use OCP\IUser;
 use OCP\IUserSession;
 use OCP\Notification\IManager as INotificationManager;
 		try {
 			$ldapRecord = $this->getLDAPUserByLoginName($uid);
 		} catch(NotOnLDAP $e) {
-			if($this->ocConfig->getSystemValue('loglevel', Util::WARN) === Util::DEBUG) {
+			if($this->ocConfig->getSystemValue('loglevel', ILogger::WARN) === ILogger::DEBUG) {
 				\OC::$server->getLogger()->logException($e, ['app' => 'user_ldap']);
 			}
 			return false;
 			Util::writeLog('user_ldap',
 				'LDAP Login: Could not get user object for DN ' . $dn .
 				'. Maybe the LDAP entry has no set display name attribute?',
-				Util::WARN);
+				ILogger::WARN);
 			return false;
 		}
 		if($user->getUsername() !== false) {
 
 		Util::writeLog('user_ldap',
 			'getUsers: Options: search '.$search.' limit '.$limit.' offset '.$offset.' Filter: '.$filter,
-			Util::DEBUG);
+			ILogger::DEBUG);
 		//do the search and translate results to Nextcloud names
 		$ldap_users = $this->access->fetchListOfUsers(
 			$filter,
 			$this->access->userManager->getAttributes(true),
 			$limit, $offset);
 		$ldap_users = $this->access->nextcloudUserNames($ldap_users);
-		Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', Util::DEBUG);
+		Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', ILogger::DEBUG);
 
 		$this->access->connection->writeToCache($cachekey, $ldap_users);
 		return $ldap_users;
 
 		if(is_null($user)) {
 			Util::writeLog('user_ldap', 'No DN found for '.$uid.' on '.
-				$this->access->connection->ldapHost, Util::DEBUG);
+				$this->access->connection->ldapHost, ILogger::DEBUG);
 			$this->access->connection->writeToCache('userExists'.$uid, false);
 			return false;
 		} else if($user instanceof OfflineUser) {

apps/user_ldap/lib/Wizard.php

 namespace OCA\User_LDAP;
 
 use OC\ServerNotAvailableException;
+use OCP\ILogger;
 
 class Wizard extends LDAPUtility {
 	/** @var \OCP\IL10N */
 			if($writeLog) {
 				\OCP\Util::writeLog('user_ldap', 'The mail attribute has ' .
 					'automatically been reset, because the original value ' .
-					'did not return any results.', \OCP\Util::INFO);
+					'did not return any results.', ILogger::INFO);
 			}
 		}
 
 		foreach($portSettings as $setting) {
 			$p = $setting['port'];
 			$t = $setting['tls'];
-			\OCP\Util::writeLog('user_ldap', 'Wiz: trying port '. $p . ', TLS '. $t, \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'Wiz: trying port '. $p . ', TLS '. $t, ILogger::DEBUG);
 			//connectAndBind may throw Exception, it needs to be catched by the
 			//callee of this method
 
 					'ldapTLS' => (int)$t
 				);
 				$this->configuration->setConfiguration($config);
-				\OCP\Util::writeLog('user_ldap', 'Wiz: detected Port ' . $p, \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('user_ldap', 'Wiz: detected Port ' . $p, ILogger::DEBUG);
 				$this->result->addChange('ldap_port', $p);
 				return $this->result;
 			}
 			$errorNo  = $this->ldap->errno($cr);
 			$errorMsg = $this->ldap->error($cr);
 			\OCP\Util::writeLog('user_ldap', 'Wiz: Could not search base '.$base.
-							' Error '.$errorNo.': '.$errorMsg, \OCP\Util::INFO);
+							' Error '.$errorNo.': '.$errorMsg, ILogger::INFO);
 			return false;
 		}
 		$entries = $this->ldap->countEntries($cr, $rr);
 				break;
 		}
 
-		\OCP\Util::writeLog('user_ldap', 'Wiz: Final filter '.$filter, \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'Wiz: Final filter '.$filter, ILogger::DEBUG);
 
 		return $filter;
 	}
 		if(!$hostInfo) {
 			throw new \Exception(self::$l->t('Invalid Host'));
 		}
-		\OCP\Util::writeLog('user_ldap', 'Wiz: Attempting to connect ', \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('user_ldap', 'Wiz: Attempting to connect ', ILogger::DEBUG);
 		$cr = $this->ldap->connect($host, $port);
 		if(!is_resource($cr)) {
 			throw new \Exception(self::$l->t('Invalid Host'));
 				}
 			}
 
-			\OCP\Util::writeLog('user_ldap', 'Wiz: Attemping to Bind ', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'Wiz: Attemping to Bind ', ILogger::DEBUG);
 			//interesting part: do the bind!
 			$login = $this->ldap->bind($cr,
 				$this->configuration->ldapAgentName,
 
 		if($login === true) {
 			$this->ldap->unbind($cr);
-			\OCP\Util::writeLog('user_ldap', 'Wiz: Bind successful to Port '. $port . ' TLS ' . (int)$tls, \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('user_ldap', 'Wiz: Bind successful to Port '. $port . ' TLS ' . (int)$tls, ILogger::DEBUG);
 			return true;
 		}
 

core/Controller/SetupController.php

 namespace OC\Core\Controller;
 
 use OC\Setup;
+use OCP\ILogger;
 
 class SetupController {
 	/** @var Setup */
 
 	public function loadAutoConfig($post) {
 		if( file_exists($this->autoConfigFile)) {
-			\OCP\Util::writeLog('core', 'Autoconfig file found, setting up ownCloud…', \OCP\Util::INFO);
+			\OCP\Util::writeLog('core', 'Autoconfig file found, setting up ownCloud…', ILogger::INFO);
 			$AUTOCONFIG = array();
 			include $this->autoConfigFile;
 			$post = array_merge ($post, $AUTOCONFIG);

core/ajax/update.php

  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
  */
+
+use OCP\ILogger;
 use Symfony\Component\EventDispatcher\GenericEvent;
 
 if (strpos(@ini_get('disable_functions'), 'set_time_limit') === false) {
 		$updater->upgrade();
 	} catch (\Exception $e) {
 		\OC::$server->getLogger()->logException($e, [
-			'level' => \OCP\Util::ERROR,
+			'level' => ILogger::ERROR,
 			'app' => 'update',
 		]);
 		$eventSource->send('failure', get_class($e) . ': ' . $e->getMessage());

lib/autoloader.php

 namespace OC;
 
 use \OCP\AutoloadNotAllowedException;
+use OCP\ILogger;
 
 class Autoloader {
 	/** @var bool */
 			 * Remove "apps/" from inclusion path for smooth migration to multi app dir
 			 */
 			if (strpos(\OC::$CLASSPATH[$class], 'apps/') === 0) {
-				\OCP\Util::writeLog('core', 'include path for class "' . $class . '" starts with "apps/"', \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('core', 'include path for class "' . $class . '" starts with "apps/"', ILogger::DEBUG);
 				$paths[] = str_replace('apps/', '', \OC::$CLASSPATH[$class]);
 			}
 		} elseif (strpos($class, 'OC_') === 0) {

lib/base.php

  *
  */
 
+use OCP\ILogger;
 use OCP\Share;
 use OC\Encryption\HookManager;
 use OC\Files\Filesystem;
 					// so log the exception
 					\OC::$server->getLogger()->logException($e, [
 						'message' => 'Exception when running cache gc.',
-						'level' => \OCP\Util::WARN,
+						'level' => ILogger::WARN,
 						'app' => 'core',
 					]);
 				}

lib/private/App/AppStore/Fetcher/AppFetcher.php

 							$releases[] = $release;
 						}
 					} catch (\InvalidArgumentException $e) {
-						$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => Util::WARN]);
+						$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => ILogger::WARN]);
 					}
 				}
 			}

lib/private/App/AppStore/Fetcher/Fetcher.php

 			$file->putContent(json_encode($responseJson));
 			return json_decode($file->getContent(), true)['data'];
 		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => Util::INFO, 'message' => 'Could not connect to appstore']);
+			$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => ILogger::INFO, 'message' => 'Could not connect to appstore']);
 			return [];
 		} catch (\Exception $e) {
-			$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => Util::INFO]);
+			$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => ILogger::INFO]);
 			return [];
 		}
 	}

lib/private/AppFramework/DependencyInjection/DIContainer.php

 use OCP\Files\IAppData;
 use OCP\GlobalScale\IConfig;
 use OCP\IL10N;
+use OCP\ILogger;
 use OCP\IRequest;
 use OCP\IServerContainer;
 use OCP\IUserSession;
 	public function log($message, $level) {
 		switch($level){
 			case 'debug':
-				$level = \OCP\Util::DEBUG;
+				$level = ILogger::DEBUG;
 				break;
 			case 'info':
-				$level = \OCP\Util::INFO;
+				$level = ILogger::INFO;
 				break;
 			case 'warn':
-				$level = \OCP\Util::WARN;
+				$level = ILogger::WARN;
 				break;
 			case 'fatal':
-				$level = \OCP\Util::FATAL;
+				$level = ILogger::FATAL;
 				break;
 			default:
-				$level = \OCP\Util::ERROR;
+				$level = ILogger::ERROR;
 				break;
 		}
 		\OCP\Util::writeLog($this->getAppName(), $message, $level);

lib/private/AppFramework/Middleware/Security/SecurityMiddleware.php

 			}
 
 			$this->logger->logException($exception, [
-				'level' => \OCP\Util::DEBUG,
+				'level' => ILogger::DEBUG,
 				'app' => 'core',
 			]);
 			return $response;

lib/private/Archive/ZIP.php

 namespace OC\Archive;
 
 use Icewind\Streams\CallbackWrapper;
+use OCP\ILogger;
 
 class ZIP extends Archive{
 	/**
 		$this->zip=new \ZipArchive();
 		if($this->zip->open($source, \ZipArchive::CREATE)) {
 		}else{
-			\OCP\Util::writeLog('files_archive', 'Error while opening archive '.$source, \OCP\Util::WARN);
+			\OCP\Util::writeLog('files_archive', 'Error while opening archive '.$source, ILogger::WARN);
 		}
 	}
 	/**

lib/private/Cache/File.php

 use OC\Files\Filesystem;
 use OC\Files\View;
 use OCP\ICache;
+use OCP\ILogger;
 use OCP\Security\ISecureRandom;
 
 class File implements ICache {
 			$this->storage = new View('/' . $user->getUID() . '/cache');
 			return $this->storage;
 		} else {
-			\OCP\Util::writeLog('core', 'Can\'t get cache storage, user not logged in', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'Can\'t get cache storage, user not logged in', ILogger::ERROR);
 			throw new \OC\ForbiddenException('Can\t get cache storage, user not logged in');
 		}
 	}

lib/private/CapabilitiesManager.php

 			} catch (QueryException $e) {
 				$this->logger->logException($e, [
 					'message' => 'CapabilitiesManager',
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'core',
 				]);
 				continue;

lib/private/DateTimeZone.php

 
 use OCP\IConfig;
 use OCP\IDateTimeZone;
+use OCP\ILogger;
 use OCP\ISession;
 
 class DateTimeZone implements IDateTimeZone {
 		try {
 			return new \DateTimeZone($timeZone);
 		} catch (\Exception $e) {
-			\OCP\Util::writeLog('datetimezone', 'Failed to created DateTimeZone "' . $timeZone . "'", \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('datetimezone', 'Failed to created DateTimeZone "' . $timeZone . "'", ILogger::DEBUG);
 			return new \DateTimeZone($this->getDefaultTimeZone());
 		}
 	}
 			}
 
 			// No timezone found, fallback to UTC
-			\OCP\Util::writeLog('datetimezone', 'Failed to find DateTimeZone for offset "' . $offset . "'", \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('datetimezone', 'Failed to find DateTimeZone for offset "' . $offset . "'", ILogger::DEBUG);
 			return new \DateTimeZone($this->getDefaultTimeZone());
 		}
 	}

lib/private/Files/Cache/Scanner.php

 use OC\Hooks\BasicEmitter;
 use OCP\Files\Cache\IScanner;
 use OCP\Files\ForbiddenException;
+use OCP\ILogger;
 use OCP\Lock\ILockingProvider;
 
 /**
 	protected function getData($path) {
 		$data = $this->storage->getMetaData($path);
 		if (is_null($data)) {
-			\OCP\Util::writeLog(Scanner::class, "!!! Path '$path' is not accessible or present !!!", \OCP\Util::DEBUG);
+			\OCP\Util::writeLog(Scanner::class, "!!! Path '$path' is not accessible or present !!!", ILogger::DEBUG);
 		}
 		return $data;
 	}
 				}
 				\OC::$server->getLogger()->logException($ex, [
 					'message' => 'Exception while scanning file "' . $child . '"',
-					'level' => \OCP\Util::DEBUG,
+					'level' => ILogger::DEBUG,
 					'app' => 'core',
 				]);
 				$exceptionOccurred = true;

lib/private/Files/Filesystem.php

 use OC\Lockdown\Filesystem\NullStorage;
 use OCP\Files\Config\IMountProvider;
 use OCP\Files\NotFoundException;
+use OCP\ILogger;
 use OCP\IUserManager;
 
 class Filesystem {
 		$userObject = $userManager->get($user);
 
 		if (is_null($userObject)) {
-			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
 			// reset flag, this will make it possible to rethrow the exception if called again
 			unset(self::$usersSetup[$user]);
 			throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
 		// workaround in case of different casings
 		if ($user !== $realUid) {
 			$stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
-			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, \OCP\Util::WARN);
+			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
 			$user = $realUid;
 
 			// again with the correct casing

lib/private/Files/Mount/MountPoint.php

 use OC\Files\Storage\StorageFactory;
 use OC\Files\Storage\Storage;
 use OCP\Files\Mount\IMountPoint;
+use OCP\ILogger;
 
 class MountPoint implements IMountPoint {
 	/**
 					// the root storage could not be initialized, show the user!
 					throw new \Exception('The root storage could not be initialized. Please contact your local administrator.', $exception->getCode(), $exception);
 				} else {
-					\OC::$server->getLogger()->logException($exception, ['level' => \OCP\Util::ERROR]);
+					\OC::$server->getLogger()->logException($exception, ['level' => ILogger::ERROR]);
 				}
 				return;
 			}
 		} else {
-			\OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
 			$this->invalidStorage = true;
 			return;
 		}

lib/private/Files/Mount/ObjectHomeMountProvider.php

 use OCP\Files\Config\IHomeMountProvider;
 use OCP\Files\Storage\IStorageFactory;
 use OCP\IConfig;
+use OCP\ILogger;
 use OCP\IUser;
 
 /**
 
 		// sanity checks
 		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
 		}
 		if (!isset($config['arguments'])) {
 			$config['arguments'] = [];
 
 		// sanity checks
 		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
 		}
 		if (!isset($config['arguments'])) {
 			$config['arguments'] = [];

lib/private/Files/ObjectStore/S3ConnectionTrait.php

 use Aws\ClientResolver;
 use Aws\S3\Exception\S3Exception;
 use Aws\S3\S3Client;
+use OCP\ILogger;
 
 trait S3ConnectionTrait {
 	/** @var array */
 			} catch (S3Exception $e) {
 				$logger->logException($e, [
 					'message' => 'Invalid remote storage.',
-					'level' => \OCP\Util::DEBUG,
+					'level' => ILogger::DEBUG,
 					'app' => 'objectstore',
 				]);
 				throw new \Exception('Creation of bucket "' . $this->bucket . '" failed. ' . $e->getMessage());

lib/private/Files/Storage/Common.php

 use OCP\Files\ReservedWordException;
 use OCP\Files\Storage\ILockingStorage;
 use OCP\Files\Storage\IStorage;
+use OCP\ILogger;
 use OCP\Lock\ILockingProvider;
 use OCP\Lock\LockedException;
 
 			return false;
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->info("External storage not available: " . $e->getMessage());
-			\OC::$server->getLogger()->logException($e, ['level' => \OCP\Util::DEBUG]);
+			\OC::$server->getLogger()->logException($e, ['level' => ILogger::DEBUG]);
 			return false;
 		}
 	}

lib/private/Files/Storage/DAV.php

 
 use Exception;
 use GuzzleHttp\Exception\RequestException;
+use OCP\ILogger;
 use Psr\Http\Message\ResponseInterface;
 use Icewind\Streams\CallbackWrapper;
 use OC\Files\Filesystem;
 					if ($response->getStatusCode() === Http::STATUS_LOCKED) {
 						throw new \OCP\Lock\LockedException($path);
 					} else {
-						Util::writeLog("webdav client", 'Guzzle get returned status code ' . $response->getStatusCode(), Util::ERROR);
+						Util::writeLog("webdav client", 'Guzzle get returned status code ' . $response->getStatusCode(), ILogger::ERROR);
 					}
 				}
 

lib/private/Files/Storage/Local.php

 use OC\Files\Storage\Wrapper\Jail;
 use OCP\Files\ForbiddenException;
 use OCP\Files\Storage\IStorage;
+use OCP\ILogger;
 
 /**
  * for local filestore, we only have to map the paths
 		$dstParent = dirname($path2);
 
 		if (!$this->isUpdatable($srcParent)) {
-			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
 			return false;
 		}
 
 		if (!$this->isUpdatable($dstParent)) {
-			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
 			return false;
 		}
 
 		if (!$this->file_exists($path1)) {
-			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
 			return false;
 		}
 
 			return $fullPath;
 		}
 
-		\OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", \OCP\Util::ERROR);
+		\OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", ILogger::ERROR);
 		throw new ForbiddenException('Following symlinks is not allowed', false);
 	}
 

lib/private/Files/Storage/Wrapper/Encryption.php

 			} catch (ModuleDoesNotExistsException $e) {
 				$this->logger->logException($e, [
 					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
-					'level' => \OCP\Util::WARN,
+					'level' => ILogger::WARN,
 					'app' => 'core',
 				]);
 			}

lib/private/Files/View.php

 use OCP\Files\Mount\IMountPoint;
 use OCP\Files\NotFoundException;
 use OCP\Files\ReservedWordException;
+use OCP\ILogger;
 use OCP\IUser;
 use OCP\Lock\ILockingProvider;
 use OCP\Lock\LockedException;
 				$hooks[] = 'write';
 				break;
 			default:
-				\OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
 		}
 
 		if ($mode !== 'r' && $mode !== 'w') {
 							// sometimes when the storage is not available it can be any exception
 							\OC::$server->getLogger()->logException($e, [
 								'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
-								'level' => \OCP\Util::ERROR,
+								'level' => ILogger::ERROR,
 								'app' => 'lib',
 							]);
 							continue;
 		if (!$targetStorage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
 			\OCP\Util::writeLog('files',
 				'It is not allowed to move one mount point into another one',
-				\OCP\Util::DEBUG);
+				ILogger::DEBUG);
 			return false;
 		}
 
 		if (count($shares) > 0) {
 			\OCP\Util::writeLog('files',
 				'It is not allowed to move one mount point into a shared folder',
-				\OCP\Util::DEBUG);
+				ILogger::DEBUG);
 			return false;
 		}
 

lib/private/Installer.php

 				$this->downloadApp($appId);
 			} catch (\Exception $e) {
 				$this->logger->logException($e, [
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'core',
 				]);
 				return false;
 			OC_Helper::rmdirr($appDir);
 			return true;
 		}else{
-			\OCP\Util::writeLog('core', 'can\'t remove app '.$appId.'. It is not installed.', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'can\'t remove app '.$appId.'. It is not installed.', ILogger::ERROR);
 
 			return false;
 		}

lib/private/Log.php

 	 * @return void
 	 */
 	public function emergency(string $message, array $context = []) {
-		$this->log(Util::FATAL, $message, $context);
+		$this->log(ILogger::FATAL, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function alert(string $message, array $context = []) {
-		$this->log(Util::ERROR, $message, $context);
+		$this->log(ILogger::ERROR, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function critical(string $message, array $context = []) {
-		$this->log(Util::ERROR, $message, $context);
+		$this->log(ILogger::ERROR, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function error(string $message, array $context = []) {
-		$this->log(Util::ERROR, $message, $context);
+		$this->log(ILogger::ERROR, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function warning(string $message, array $context = []) {
-		$this->log(Util::WARN, $message, $context);
+		$this->log(ILogger::WARN, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function notice(string $message, array $context = []) {
-		$this->log(Util::INFO, $message, $context);
+		$this->log(ILogger::INFO, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function info(string $message, array $context = []) {
-		$this->log(Util::INFO, $message, $context);
+		$this->log(ILogger::INFO, $message, $context);
 	}
 
 	/**
 	 * @return void
 	 */
 	public function debug(string $message, array $context = []) {
-		$this->log(Util::DEBUG, $message, $context);
+		$this->log(ILogger::DEBUG, $message, $context);
 	}
 
 
 
 		// if log condition is satisfied change the required log level to DEBUG
 		if ($this->logConditionSatisfied) {
-			return Util::DEBUG;
+			return ILogger::DEBUG;
 		}
 
 		if (isset($context['app'])) {
 			if (!empty($logCondition)
 				&& isset($logCondition['apps'])
 				&& in_array($app, $logCondition['apps'], true)) {
-				return Util::DEBUG;
+				return ILogger::DEBUG;
 			}
 		}
 
-		return min($this->config->getValue('loglevel', Util::WARN), Util::FATAL);
+		return min($this->config->getValue('loglevel', ILogger::WARN), ILogger::FATAL);
 	}
 
 	/**
 	 */
 	public function logException(\Throwable $exception, array $context = []) {
 		$app = $context['app'] ?? 'no app in context';
-		$level = $context['level'] ?? Util::ERROR;
+		$level = $context['level'] ?? ILogger::ERROR;
 
 		$serializer = new ExceptionSerializer();
 		$data = $serializer->serializeException($exception);

lib/private/Log/File.php

 
 namespace OC\Log;
 
+use OCP\ILogger;
+
 /**
  * logging utilities
  *
 	 */
 	public static function getEntries($limit=50, $offset=0) {
 		self::init();
-		$minLevel = \OC::$server->getSystemConfig()->getValue("loglevel", \OCP\Util::WARN);
+		$minLevel = \OC::$server->getSystemConfig()->getValue("loglevel", ILogger::WARN);
 		$entries = array();
 		$handle = @fopen(self::$logFile, 'rb');
 		if ($handle) {

lib/private/Log/Rotate.php

  */
 
 namespace OC\Log;
+use OCP\ILogger;
 
 /**
  * This rotates the current logfile to a new name, this way the total log usage
 		$rotatedLogfile = $logfile.'.1';
 		rename($logfile, $rotatedLogfile);
 		$msg = 'Log file "'.$logfile.'" was over '.$this->max_log_size.' bytes, moved to "'.$rotatedLogfile.'"';
-		\OCP\Util::writeLog(Rotate::class, $msg, \OCP\Util::WARN);
+		\OCP\Util::writeLog(Rotate::class, $msg, ILogger::WARN);
 	}
 }

lib/private/Log/Syslog.php

 
 namespace OC\Log;
 
+use OCP\ILogger;
+
 class Syslog {
 	static protected $levels = array(
-		\OCP\Util::DEBUG => LOG_DEBUG,
-		\OCP\Util::INFO => LOG_INFO,
-		\OCP\Util::WARN => LOG_WARNING,
-		\OCP\Util::ERROR => LOG_ERR,
-		\OCP\Util::FATAL => LOG_CRIT,
+		ILogger::DEBUG => LOG_DEBUG,
+		ILogger::INFO => LOG_INFO,
+		ILogger::WARN => LOG_WARNING,
+		ILogger::ERROR => LOG_ERR,
+		ILogger::FATAL => LOG_CRIT,
 	);
 
 	/**

lib/private/NaturalSort.php

 
 namespace OC;
 
+use OCP\ILogger;
+
 class NaturalSort {
 	private static $instance;
 	private $collator;
 		// or inject an instance of \OC\NaturalSort_DefaultCollator to force using Owncloud's default collator
 		if (isset($injectedCollator)) {
 			$this->collator = $injectedCollator;
-			\OCP\Util::writeLog('core', 'forced use of '.get_class($injectedCollator), \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', 'forced use of '.get_class($injectedCollator), ILogger::DEBUG);
 		}
 	}
 

lib/private/Preview/Bitmap.php

 namespace OC\Preview;
 
 use Imagick;
+use OCP\ILogger;
 
 /**
  * Creates a PNG preview using ImageMagick via the PECL extension
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => 'Imagick says:',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;

lib/private/Preview/Office.php

  */
 namespace OC\Preview;
 
+use OCP\ILogger;
+
 abstract class Office extends Provider {
 	private $cmd;
 
 			unlink($absPath);
 			unlink($pdfPreview);
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;

lib/private/Preview/SVG.php

  */
 namespace OC\Preview;
 
+use OCP\ILogger;
+
 class SVG extends Provider {
 	/**
 	 * {@inheritDoc}
 			$svg->setImageFormat('png32');
 		} catch (\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;

lib/private/Settings/Manager.php

 				/** @var ISection $section */
 				$section = \OC::$server->query($class);
 			} catch (QueryException $e) {
-				$this->log->logException($e, ['level' => Util::INFO]);
+				$this->log->logException($e, ['level' => ILogger::INFO]);
 				continue;
 			}
 
 			if (!$section instanceof ISection) {
-				$this->log->logException(new \InvalidArgumentException('Invalid settings section registered'), ['level' => Util::INFO]);
+				$this->log->logException(new \InvalidArgumentException('Invalid settings section registered'), ['level' => ILogger::INFO]);
 				continue;
 			}
 
 				/** @var ISettings $setting */
 				$setting = \OC::$server->query($class);
 			} catch (QueryException $e) {
-				$this->log->logException($e, ['level' => Util::INFO]);
+				$this->log->logException($e, ['level' => ILogger::INFO]);
 				continue;
 			}
 
 			if (!$setting instanceof ISettings) {
-				$this->log->logException(new \InvalidArgumentException('Invalid settings setting registered'), ['level' => Util::INFO]);
+				$this->log->logException(new \InvalidArgumentException('Invalid settings setting registered'), ['level' => ILogger::INFO]);
 				continue;
 			}
 

lib/private/Setup/MySQL.php

 
 use OC\DB\MySqlTools;
 use OCP\IDBConnection;
+use OCP\ILogger;
 
 class MySQL extends AbstractDatabase {
 	public $dbprettyname = 'MySQL/MariaDB';
 		} catch (\Exception $ex) {
 			$this->logger->logException($ex, [
 				'message' => 'Database creation failed.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'mysql.setup',
 			]);
 			return;
 		} catch (\Exception $ex) {
 			$this->logger->logException($ex, [
 				'message' => 'Could not automatically grant privileges, this can be ignored if database user already had privileges.',
-				'level' => \OCP\Util::DEBUG,
+				'level' => ILogger::DEBUG,
 				'app' => 'mysql.setup',
 			]);
 		}
 		catch (\Exception $ex){
 			$this->logger->logException($ex, [
 				'message' => 'Database user creation failed.',
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'mysql.setup',
 			]);
 		}
 		} catch (\Exception $ex) {
 			$this->logger->logException($ex, [
 				'message' => 'Can not create a new MySQL user, will continue with the provided user.',
-				'level' => \OCP\Util::INFO,
+				'level' => ILogger::INFO,
 				'app' => 'mysql.setup',
 			]);
 		}

lib/private/Share/Share.php

 
 use OCP\DB\QueryBuilder\IQueryBuilder;
 use OCP\IConfig;
+use OCP\ILogger;
 use OCP\Util;
 
 /**
 			\OCP\Util::writeLog('OCP\Share',
 				'Sharing backend '.$class.' not registered, '.self::$backendTypes[$itemType]['class']
 				.' is already registered for '.$itemType,
-				\OCP\Util::WARN);
+				ILogger::WARN);
 		}
 		return false;
 	}
 		$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*share` WHERE `token` = ?', 1);
 		$result = $query->execute(array($token));
 		if ($result === false) {
-			\OCP\Util::writeLog('OCP\Share', \OC_DB::getErrorMessage() . ', token=' . $token, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('OCP\Share', \OC_DB::getErrorMessage() . ', token=' . $token, ILogger::ERROR);
 		}
 		$row = $result->fetchRow();
 		if ($row === false) {
 		if ($backend->isShareTypeAllowed($shareType) === false) {
 			$message = 'Sharing %s failed, because the backend does not allow shares from type %i';
 			$message_t = $l->t('Sharing %s failed, because the backend does not allow shares from type %i', array($itemSourceName, $shareType));
-			\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareType), \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareType), ILogger::DEBUG);
 			throw new \Exception($message_t);
 		}
 
 			if (!$path) {
 				$message = 'Sharing %s failed, because the file does not exist';
 				$message_t = $l->t('Sharing %s failed, because the file does not exist', array($itemSourceName));
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 			// verify that the user has share permission
 			if (!\OC\Files\Filesystem::isSharable($path) || \OCP\Util::isSharingDisabledForUser()) {
 				$message = 'You are not allowed to share %s';
 				$message_t = $l->t('You are not allowed to share %s', [$path]);
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $path), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $path), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 		}
 			foreach ($mounts as $mount) {
 				if ($mount->getStorage()->instanceOfStorage('\OCA\Files_Sharing\ISharedStorage')) {
 					$message = 'Sharing "' . $itemSourceName . '" failed, because it contains files shared with you!';
-					\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', $message, ILogger::DEBUG);
 					throw new \Exception($message);
 				}
 
 			if ($shareWith == $uidOwner) {
 				$message = 'Sharing %s failed, because you can not share with yourself';
 				$message_t = $l->t('Sharing %s failed, because you can not share with yourself', [$itemName]);
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 			if (!\OC::$server->getUserManager()->userExists($shareWith)) {
 				$message = 'Sharing %s failed, because the user %s does not exist';
 				$message_t = $l->t('Sharing %s failed, because the user %s does not exist', array($itemSourceName, $shareWith));
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 			if ($shareWithinGroupOnly) {
 					$message = 'Sharing %s failed, because the user '
 						.'%s is not a member of any groups that %s is a member of';
 					$message_t = $l->t('Sharing %s failed, because the user %s is not a member of any groups that %s is a member of', array($itemName, $shareWith, $uidOwner));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemName, $shareWith, $uidOwner), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemName, $shareWith, $uidOwner), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 			}
 				if ($checkExists['uid_owner'] != $uidOwner || $checkExists['share_type'] == $shareType) {
 					$message = 'Sharing %s failed, because this item is already shared with %s';
 					$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 			}
 				if ($checkExists['uid_owner'] != $uidOwner || $checkExists['share_type'] == $shareType) {
 					$message = 'Sharing %s failed, because this item is already shared with user %s';
 					$message_t = $l->t('Sharing %s failed, because this item is already shared with user %s', array($itemSourceName, $shareWith));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::ERROR);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::ERROR);
 					throw new \Exception($message_t);
 				}
 			}
 			if (!\OC::$server->getGroupManager()->groupExists($shareWith)) {
 				$message = 'Sharing %s failed, because the group %s does not exist';
 				$message_t = $l->t('Sharing %s failed, because the group %s does not exist', array($itemSourceName, $shareWith));
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 			if ($shareWithinGroupOnly) {
 					$message = 'Sharing %s failed, because '
 						. '%s is not a member of the group %s';
 					$message_t = $l->t('Sharing %s failed, because %s is not a member of the group %s', array($itemSourceName, $uidOwner, $shareWith));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner, $shareWith), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner, $shareWith), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 			}
 				if ($checkExists['share_with'] === $shareWith && $checkExists['share_type'] === \OCP\Share::SHARE_TYPE_GROUP) {
 					$message = 'Sharing %s failed, because this item is already shared with %s';
 					$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 			}
 				if (\OCP\Util::isPublicLinkPasswordRequired() && empty($shareWith)) {
 					$message = 'You need to provide a password to create a public link, only protected links are allowed';
 					$message_t = $l->t('You need to provide a password to create a public link, only protected links are allowed');
-					\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', $message, ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 
 			}
 			$message = 'Sharing %s failed, because sharing with links is not allowed';
 			$message_t = $l->t('Sharing %s failed, because sharing with links is not allowed', array($itemSourceName));
-			\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), ILogger::DEBUG);
 			throw new \Exception($message_t);
 		} else if ($shareType === self::SHARE_TYPE_REMOTE) {
 
 				$shareWith, $uidOwner, self::FORMAT_NONE, null, 1, true, true)) {
 					$message = 'Sharing %s failed, because this item is already shared with %s';
 					$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 					throw new \Exception($message_t);
 			}
 
 			if (Helper::isSameUserOnSameServer($user, $remote, $currentUser, $currentServer)) {
 				$message = 'Not allowed to create a federated share with the same user.';
 				$message_t = $l->t('Not allowed to create a federated share with the same user');
-				\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', $message, ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 
 			// Future share types need to include their own conditions
 			$message = 'Share type %s is not valid for %s';
 			$message_t = $l->t('Share type %s is not valid for %s', array($shareType, $itemSource));
-			\OCP\Util::writeLog('OCP\Share', sprintf($message, $shareType, $itemSource), \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('OCP\Share', sprintf($message, $shareType, $itemSource), ILogger::DEBUG);
 			throw new \Exception($message_t);
 		}
 
 		$result = $query->execute(array($status, $itemType, $itemSource, $shareType, $recipient));
 
 		if($result === false) {
-			\OCP\Util::writeLog('OCP\Share', 'Couldn\'t set send mail status', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('OCP\Share', 'Couldn\'t set send mail status', ILogger::ERROR);
 		}
 	}
 
 			if ($date > $maxDate) {
 				$warning = 'Cannot set expiration date. Shares cannot expire later than ' . $maxDays . ' after they have been shared';
 				$warning_t = $l->t('Cannot set expiration date. Shares cannot expire later than %s after they have been shared', array($maxDays));
-				\OCP\Util::writeLog('OCP\Share', $warning, \OCP\Util::WARN);
+				\OCP\Util::writeLog('OCP\Share', $warning, ILogger::WARN);
 				throw new \Exception($warning_t);
 			}
 		}
 		if ($date < $today) {
 			$message = 'Cannot set expiration date. Expiration date is in the past';
 			$message_t = $l->t('Cannot set expiration date. Expiration date is in the past');
-			\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::WARN);
+			\OCP\Util::writeLog('OCP\Share', $message, ILogger::WARN);
 			throw new \Exception($message_t);
 		}
 
 				if (!(self::$backends[$itemType] instanceof \OCP\Share_Backend)) {
 					$message = 'Sharing backend %s must implement the interface OCP\Share_Backend';
 					$message_t = $l->t('Sharing backend %s must implement the interface OCP\Share_Backend', array($class));
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), \OCP\Util::ERROR);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), ILogger::ERROR);
 					throw new \Exception($message_t);
 				}
 				return self::$backends[$itemType];
 			} else {
 				$message = 'Sharing backend %s not found';
 				$message_t = $l->t('Sharing backend %s not found', array($class));
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), \OCP\Util::ERROR);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), ILogger::ERROR);
 				throw new \Exception($message_t);
 			}
 		}
 		$message = 'Sharing backend for %s not found';
 		$message_t = $l->t('Sharing backend for %s not found', array($itemType));
-		\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemType), \OCP\Util::ERROR);
+		\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemType), ILogger::ERROR);
 		throw new \Exception($message_t);
 	}
 
 		if ($result === false) {
 			\OCP\Util::writeLog('OCP\Share',
 				\OC_DB::getErrorMessage() . ', select=' . $select . ' where=',
-				\OCP\Util::ERROR);
+				ILogger::ERROR);
 		}
 		$items = array();
 		$targets = array();
 					if ($result === false) {
 						\OCP\Util::writeLog('OCP\Share', 'Can\'t select parent: ' .
 							\OC_DB::getErrorMessage() . ', select=' . $select . ' where=' . $where,
-							\OCP\Util::ERROR);
+							ILogger::ERROR);
 					} else {
 						$parentRow = $parentResult->fetchRow();
 						$tmpPath = $parentRow['file_target'];
 				$message = 'Sharing %s failed, because the user %s is the original sharer';
 				$message_t = $l->t('Sharing failed, because the user %s is the original sharer', [$shareWith]);
 
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 		}
 					$message = 'Sharing %s failed, because the permissions exceed permissions granted to %s';
 					$message_t = $l->t('Sharing %s failed, because the permissions exceed permissions granted to %s', array($itemSourceName, $uidOwner));
 
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				} else {
 					// TODO Don't check if inside folder
 				$message = 'Sharing %s failed, because resharing is not allowed';
 				$message_t = $l->t('Sharing %s failed, because resharing is not allowed', array($itemSourceName));
 
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 		} else {
 				$message = 'Sharing %s failed, because the sharing backend for '
 					.'%s could not find its source';
 				$message_t = $l->t('Sharing %s failed, because the sharing backend for %s could not find its source', array($itemSource, $itemType));
-				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource, $itemType), \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource, $itemType), ILogger::DEBUG);
 				throw new \Exception($message_t);
 			}
 			if ($backend instanceof \OCP\Share_Backend_File_Dependent) {
 					$message = 'Sharing %s failed, because the file could not be found in the file cache';
 					$message_t = $l->t('Sharing %s failed, because the file could not be found in the file cache', array($itemSource));
 
-					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource), \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource), ILogger::DEBUG);
 					throw new \Exception($message_t);
 				}
 			} else {

lib/private/Tags.php

 use OC\Tagging\Tag;
 use OC\Tagging\TagMapper;
 use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\ILogger;
 
 class Tags implements \OCP\ITags {
 
 					$entries[$objId][] = $row['category'];
 				}
 				if ($result === null) {
-					\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), \OCP\Util::ERROR);
+					\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), ILogger::ERROR);
 					return false;
 				}
 			}
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		} elseif(is_string($tag)) {
 			$tag = trim($tag);
 			if($tag === '') {
-				\OCP\Util::writeLog('core', __METHOD__.', Cannot use empty tag names', \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('core', __METHOD__.', Cannot use empty tag names', ILogger::DEBUG);
 				return false;
 			}
 			$tagId = $this->getTagId($tag);
 			$stmt = \OC_DB::prepare($sql);
 			$result = $stmt->execute(array($tagId));
 			if ($result === null) {
-				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), ILogger::ERROR);
 				return false;
 			}
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		$name = trim($name);
 
 		if($name === '') {
-			\OCP\Util::writeLog('core', __METHOD__.', Cannot add an empty tag', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', __METHOD__.', Cannot add an empty tag', ILogger::DEBUG);
 			return false;
 		}
 		if($this->userHasTag($name, $this->user)) {
-			\OCP\Util::writeLog('core', __METHOD__.', name: ' . $name. ' exists already', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', __METHOD__.', name: ' . $name. ' exists already', ILogger::DEBUG);
 			return false;
 		}
 		try {
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		}
-		\OCP\Util::writeLog('core', __METHOD__.', id: ' . $tag->getId(), \OCP\Util::DEBUG);
+		\OCP\Util::writeLog('core', __METHOD__.', id: ' . $tag->getId(), ILogger::DEBUG);
 		return $tag->getId();
 	}
 
 		$to = trim($to);
 
 		if($to === '' || $from === '') {
-			\OCP\Util::writeLog('core', __METHOD__.', Cannot use empty tag names', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', __METHOD__.', Cannot use empty tag names', ILogger::DEBUG);
 			return false;
 		}
 
 			$key = $this->getTagByName($from);
 		}
 		if($key === false) {
-			\OCP\Util::writeLog('core', __METHOD__.', tag: ' . $from. ' does not exist', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', __METHOD__.', tag: ' . $from. ' does not exist', ILogger::DEBUG);
 			return false;
 		}
 		$tag = $this->tags[$key];
 
 		if($this->userHasTag($to, $tag->getOwner())) {
-			\OCP\Util::writeLog('core', __METHOD__.', A tag named ' . $to. ' already exists for user ' . $tag->getOwner() . '.', \OCP\Util::DEBUG);
+			\OCP\Util::writeLog('core', __METHOD__.', A tag named ' . $to. ' already exists for user ' . $tag->getOwner() . '.', ILogger::DEBUG);
 			return false;
 		}
 
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 				} catch(\Exception $e) {
 					\OC::$server->getLogger()->logException($e, [
 						'message' => __METHOD__,
-						'level' => \OCP\Util::ERROR,
+						'level' => ILogger::ERROR,
 						'app' => 'core',
 					]);
 				}
 			// reload tags to get the proper ids.
 			$this->tags = $this->mapper->loadTags($this->owners, $this->type);
 			\OCP\Util::writeLog('core', __METHOD__.', tags: ' . print_r($this->tags, true),
-				\OCP\Util::DEBUG);
+				ILogger::DEBUG);
 			// Loop through temporarily cached objectid/tagname pairs
 			// and save relations.
 			$tags = $this->tags;
 			$dbConnection = \OC::$server->getDatabaseConnection();
 			foreach(self::$relations as $relation) {
 				$tagId = $this->getTagId($relation['tag']);
-				\OCP\Util::writeLog('core', __METHOD__ . 'catid, ' . $relation['tag'] . ' ' . $tagId, \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('core', __METHOD__ . 'catid, ' . $relation['tag'] . ' ' . $tagId, ILogger::DEBUG);
 				if($tagId) {
 					try {
 						$dbConnection->insertIfNotExist(self::RELATION_TABLE,
 					} catch(\Exception $e) {
 						\OC::$server->getLogger()->logException($e, [
 							'message' => __METHOD__,
-							'level' => \OCP\Util::ERROR,
+							'level' => ILogger::ERROR,
 							'app' => 'core',
 						]);
 					}
 			self::$relations = array(); // reset
 		} else {
 			\OCP\Util::writeLog('core', __METHOD__.', $this->tags is not an array! '
-				. print_r($this->tags, true), \OCP\Util::ERROR);
+				. print_r($this->tags, true), ILogger::ERROR);
 		}
 	}
 
 				. 'WHERE `uid` = ?');
 			$result = $stmt->execute(array($arguments['uid']));
 			if ($result === null) {
-				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), ILogger::ERROR);
 			}
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 		}
 					} catch(\Exception $e) {
 						\OC::$server->getLogger()->logException($e, [
 							'message' => __METHOD__,
-							'level' => \OCP\Util::ERROR,
+							'level' => ILogger::ERROR,
 							'app' => 'core',
 						]);
 					}
 			} catch(\Exception $e) {
 				\OC::$server->getLogger()->logException($e, [
 					'message' => __METHOD__,
-					'level' => \OCP\Util::ERROR,
+					'level' => ILogger::ERROR,
 					'app' => 'core',
 				]);
 			}
 				. 'WHERE `uid` = ?');
 			$result = $stmt->execute(array($arguments['uid']));
 			if ($result === null) {
-				\OCP\Util::writeLog('core', __METHOD__. ', DB error: ' . \OC::$server->getDatabaseConnection()->getError(), \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', __METHOD__. ', DB error: ' . \OC::$server->getDatabaseConnection()->getError(), ILogger::ERROR);
 			}
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 		}
 			$stmt = \OC_DB::prepare($query);
 			$result = $stmt->execute($updates);
 			if ($result === null) {
-				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(), ILogger::ERROR);
 				return false;
 			}
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return array();
 		if(is_string($tag) && !is_numeric($tag)) {
 			$tag = trim($tag);
 			if($tag === '') {
-				\OCP\Util::writeLog('core', __METHOD__.', Cannot add an empty tag', \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('core', __METHOD__.', Cannot add an empty tag', ILogger::DEBUG);
 				return false;
 			}
 			if(!$this->hasTag($tag)) {
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		if(is_string($tag) && !is_numeric($tag)) {
 			$tag = trim($tag);
 			if($tag === '') {
-				\OCP\Util::writeLog('core', __METHOD__.', Tag name is empty', \OCP\Util::DEBUG);
+				\OCP\Util::writeLog('core', __METHOD__.', Tag name is empty', ILogger::DEBUG);
 				return false;
 			}
 			$tagId =  $this->getTagId($tag);
 		} catch(\Exception $e) {
 			\OC::$server->getLogger()->logException($e, [
 				'message' => __METHOD__,
-				'level' => \OCP\Util::ERROR,
+				'level' => ILogger::ERROR,
 				'app' => 'core',
 			]);
 			return false;
 		array_filter($names);
 
 		\OCP\Util::writeLog('core', __METHOD__ . ', before: '
-			. print_r($this->tags, true), \OCP\Util::DEBUG);
+			. print_r($this->tags, true), ILogger::DEBUG);
 		foreach($names as $name) {
 			$id = null;
 
 				$this->mapper->delete($tag);
 			} else {
 				\OCP\Util::writeLog('core', __METHOD__ . 'Cannot delete tag ' . $name
-					. ': not found.', \OCP\Util::ERROR);
+					. ': not found.', ILogger::ERROR);
 			}
 			if(!is_null($id) && $id !== false) {
 				try {
 					if ($result === null) {
 						\OCP\Util::writeLog('core',
 							__METHOD__. 'DB error: ' . \OC::$server->getDatabaseConnection()->getError(),
-							\OCP\Util::ERROR);
+							ILogger::ERROR);
 						return false;
 					}
 				} catch(\Exception $e) {
 					\OC::$server->getLogger()->logException($e, [
 						'message' => __METHOD__,
-						'level' => \OCP\Util::ERROR,
+						'level' => ILogger::ERROR,
 						'app' => 'core',
 					]);
 					return false;

lib/private/Updater.php

 		$this->emitRepairEvents();
 		$this->logAllEvents();
 
-		$logLevel = $this->config->getSystemValue('loglevel', Util::WARN);
+		$logLevel = $this->config->getSystemValue('loglevel', ILogger::WARN);
 		$this->emit('\OC\Updater', 'setDebugLogLevel', [ $logLevel, $this->logLevelNames[$logLevel] ]);
-		$this->config->setSystemValue('loglevel', Util::DEBUG);
+		$this->config->setSystemValue('loglevel', ILogger::DEBUG);
 
 		$wasMaintenanceModeEnabled = $this->config->getSystemValue('maintenance', false);
 

lib/private/User/Database.php

 
 use OC\Cache\CappedMemoryCache;
 use OCP\IDBConnection;
+use OCP\ILogger;
 use OCP\User\Backend\ABackend;
 use OCP\User\Backend\ICheckPasswordBackend;
 use OCP\User\Backend\ICountUsersBackend;
 		$query = \OC_DB::prepare('SELECT COUNT(*) FROM `*PREFIX*users`');
 		$result = $query->execute();
 		if ($result === false) {
-			Util::writeLog('core', \OC_DB::getErrorMessage(), Util::ERROR);
+			Util::writeLog('core', \OC_DB::getErrorMessage(), ILogger::ERROR);
 			return false;
 		}
 		return $result->fetchOne();

lib/private/legacy/app.php

 use OC\Installer;
 use OC\Repair;
 use OCP\App\ManagerEvent;
+use OCP\ILogger;
 
 /**
  * This class manages the apps. It allows them to register and integrate in the
 			}
 		}
 
-		\OCP\Util::writeLog('core', 'No application directories are marked as writable.', \OCP\Util::ERROR);
+		\OCP\Util::writeLog('core', 'No application directories are marked as writable.', ILogger::ERROR);
 		return null;
 	}
 
 
 		foreach (OC::$APPSROOTS as $apps_dir) {
 			if (!is_readable($apps_dir['path'])) {
-				\OCP\Util::writeLog('core', 'unable to read app folder : ' . $apps_dir['path'], \OCP\Util::WARN);
+				\OCP\Util::writeLog('core', 'unable to read app folder : ' . $apps_dir['path'], ILogger::WARN);
 				continue;
 			}
 			$dh = opendir($apps_dir['path']);
 
 				$info = OC_App::getAppInfo($app, false, $langCode);
 				if (!is_array($info)) {
-					\OCP\Util::writeLog('core', 'Could not read app info file for app "' . $app . '"', \OCP\Util::ERROR);
+					\OCP\Util::writeLog('core', 'Could not read app info file for app "' . $app . '"', ILogger::ERROR);
 					continue;
 				}
 
 				if (!isset($info['name'])) {
-					\OCP\Util::writeLog('core', 'App id "' . $app . '" has no name in appinfo', \OCP\Util::ERROR);
+					\OCP\Util::writeLog('core', 'App id "' . $app . '" has no name in appinfo', ILogger::ERROR);
 					continue;
 				}
 
 				}
 				return new \OC\Files\View('/' . OC_User::getUser() . '/' . $appId);
 			} else {
-				\OCP\Util::writeLog('core', 'Can\'t get app storage, app ' . $appId . ', user not logged in', \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', 'Can\'t get app storage, app ' . $appId . ', user not logged in', ILogger::ERROR);
 				return false;
 			}
 		} else {
-			\OCP\Util::writeLog('core', 'Can\'t get app storage, app ' . $appId . ' not enabled', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('core', 'Can\'t get app storage, app ' . $appId . ' not enabled', ILogger::ERROR);
 			return false;
 		}
 	}

lib/private/legacy/db.php

  *
  */
 
+use OCP\ILogger;
+
 /**
  * This class manages the access to the database. It basically is a wrapper for
  * Doctrine with some adaptions.
 		try {
 			$result = $schemaManager->updateDbFromStructure($file);
 		} catch (Exception $e) {
-			\OCP\Util::writeLog('core', 'Failed to update database structure ('.$e.')', \OCP\Util::FATAL);
+			\OCP\Util::writeLog('core', 'Failed to update database structure ('.$e.')', ILogger::FATAL);
 			throw $e;
 		}
 		return $result;

lib/private/legacy/files.php

 
 use OC\Files\View;
 use OC\Streamer;
+use OCP\ILogger;
 use OCP\Lock\ILockingProvider;
 
 /**
 			if (!$handle) {
 				\OCP\Util::writeLog('files',
 					'Can\'t write upload limit to ' . $filename . '. Please check the file permissions',
-					\OCP\Util::WARN);
+					ILogger::WARN);
 				$success = false;
 				continue; // try to update as many files as possible
 			}

lib/private/legacy/user.php

  *
  */
 
+use OCP\ILogger;
+
 /**
  * This class provides wrapper methods for user management. Multiple backends are
  * supported. User management operations are delegated to the configured backend for
 				case 'database':
 				case 'mysql':
 				case 'sqlite':
-					\OCP\Util::writeLog('core', 'Adding user backend ' . $backend . '.', \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('core', 'Adding user backend ' . $backend . '.', ILogger::DEBUG);
 					self::$_usedBackends[$backend] = new \OC\User\Database();
 					\OC::$server->getUserManager()->registerBackend(self::$_usedBackends[$backend]);
 					break;
 					\OC::$server->getUserManager()->registerBackend(self::$_usedBackends[$backend]);
 					break;
 				default:
-					\OCP\Util::writeLog('core', 'Adding default user backend ' . $backend . '.', \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('core', 'Adding default user backend ' . $backend . '.', ILogger::DEBUG);
 					$className = 'OC_USER_' . strtoupper($backend);
 					self::$_usedBackends[$backend] = new $className();
 					\OC::$server->getUserManager()->registerBackend(self::$_usedBackends[$backend]);
 					self::useBackend($backend);
 					self::$_setupedBackends[] = $i;
 				} else {
-					\OCP\Util::writeLog('core', 'User backend ' . $class . ' already initialized.', \OCP\Util::DEBUG);
+					\OCP\Util::writeLog('core', 'User backend ' . $class . ' already initialized.', ILogger::DEBUG);
 				}
 			} else {
-				\OCP\Util::writeLog('core', 'User backend ' . $class . ' not found.', \OCP\Util::ERROR);
+				\OCP\Util::writeLog('core', 'User backend ' . $class . ' not found.', ILogger::ERROR);
 			}
 		}
 	}

lib/private/legacy/util.php

 
 use OCP\IConfig;
 use OCP\IGroupManager;
+use OCP\ILogger;
 use OCP\IUser;
 
 class OC_Util {
 	private static function initObjectStoreRootFS($config) {
 		// check misconfiguration
 		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
 		}
 		if (!isset($config['arguments'])) {
 			$config['arguments'] = array();
 	private static function initObjectStoreMultibucketRootFS($config) {
 		// check misconfiguration
 		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
 		}
 		if (!isset($config['arguments'])) {
 			$config['arguments'] = array();
 			\OCP\Util::writeLog(
 				'files_skeleton',
 				'copying skeleton for '.$userId.' from '.$skeletonDirectory.' to '.$userDirectory->getFullPath('/'),
-				\OCP\Util::DEBUG
+				ILogger::DEBUG
 			);
 			self::copyr($skeletonDirectory, $userDirectory);
 			// update the file cache
 		// XCache
 		if (function_exists('xcache_clear_cache')) {
 			if (\OC::$server->getIniWrapper()->getBool('xcache.admin.enable_auth')) {
-				\OCP\Util::writeLog('core', 'XCache opcode cache will not be cleared because "xcache.admin.enable_auth" is enabled.', \OCP\Util::WARN);
+				\OCP\Util::writeLog('core', 'XCache opcode cache will not be cleared because "xcache.admin.enable_auth" is enabled.', ILogger::WARN);
 			} else {
 				@xcache_clear_cache(XC_TYPE_PHP, 0);
 			}

lib/public/ILogger.php

  * https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md#3-psrlogloggerinterface
  */
 interface ILogger {
+	/**
+	 * @since 14.0.0
+	 */
+	const DEBUG=0;
+	/**
+	 * @since 14.0.0
+	 */
+	const INFO=1;
+	/**
+	 * @since 14.0.0
+	 */
+	const WARN=2;
+	/**
+	 * @since 14.0.0
+	 */
+	const ERROR=3;
+	/**
+	 * @since 14.0.0
+	 */
+	const FATAL=4;
+
 	/**
 	 * System is unusable.
 	 *

lib/public/Util.php

  * @since 4.0.0
  */
 class Util {
-	// consts for Logging
+	/**
+	 * @deprecated 14.0.0 use \OCP\ILogger::DEBUG
+	 */
 	const DEBUG=0;
+	/**
+	 * @deprecated 14.0.0 use \OCP\ILogger::INFO
+	 */
 	const INFO=1;
+	/**
+	 * @deprecated 14.0.0 use \OCP\ILogger::WARN
+	 */
 	const WARN=2;
+	/**
+	 * @deprecated 14.0.0 use \OCP\ILogger::ERROR
+	 */
 	const ERROR=3;
+	/**
+	 * @deprecated 14.0.0 use \OCP\ILogger::FATAL
+	 */
 	const FATAL=4;
 
 	/** \OCP\Share\IManager */
 	 * @since ....0.0 - parameter $level was added in 7.0.0
 	 * @deprecated 8.2.0 use logException of \OCP\ILogger
 	 */
-	public static function logException( $app, \Exception $ex, $level = \OCP\Util::FATAL ) {
+	public static function logException( $app, \Exception $ex, $level = ILogger::FATAL) {
 		\OC::$server->getLogger()->logException($ex, ['app' => $app]);
 	}
 

settings/Controller/UsersController.php

 				} catch (\Exception $e) {
 					$this->log->logException($e, [
 						'message' => "Can't send new user mail to $email",
-						'level' => \OCP\Util::ERROR,
+						'level' => ILogger::ERROR,
 						'app' => 'settings',
 					]);
 				}

settings/ajax/enableapp.php

  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
  */
+
+use OCP\ILogger;
+
 OC_JSON::checkAdminUser();
 \OC_JSON::callCheck();
 
 	OC_JSON::success(['data' => ['update_required' => $updateRequired]]);
 } catch (Exception $e) {
 	\OC::$server->getLogger()->logException($e, [
-		'level' => \OCP\Util::DEBUG,
+		'level' => ILogger::DEBUG,
 		'app' => 'core',
 	]);
 	OC_JSON::error(array("data" => array("message" => $e->getMessage()) ));

tests/lib/Log/FileTest.php

 namespace Test\Log;
 
 use OC\Log\File;
+use OCP\ILogger;
 use Test\TestCase;
 
 /**
 
 		# set format & write log line
 		$config->setSystemValue('logdateformat', 'u');
-		File::write('test', 'message', \OCP\Util::ERROR);
-		
+		File::write('test', 'message', ILogger::ERROR);
+
 		# read log line
 		$handle = @fopen($config->getSystemValue('logfile'), 'r');
 		$line = fread($handle, 1000);

tests/lib/LoggerTest.php

 namespace Test;
 
 use OC\Log;
+use OCP\ILogger;
 
 class LoggerTest extends TestCase {
 
 		$this->config->expects($this->any())
 			->method('getValue')
 			->will(($this->returnValueMap([
-				['loglevel', \OCP\Util::WARN, \OCP\Util::WARN],
+				['loglevel', ILogger::WARN, ILogger::WARN],
 				['log.condition', [], ['apps' => ['files']]]
 			])));
 		$logger = $this->logger;