Help me een PHP-script te ontwikkelen dat een aangepaste logmechanisme implementeert met dynamische logniveaus en opslagopties.
description
Gebruikers zullen profiteren van een flexibel en robuust logsysteem dat op hun specifieke behoeften kan worden afgestemd, wat de foutopsporing en de algehele betrouwbaarheid van de toepassing verbetert.
prompt
try_prompt
Ik wil een PHP-loggingsysteem maken dat me toestaat om dynamische logniveaus (zoals debug, info, waarschuwing, fout) te specificeren en verschillende opslagopties te kiezen (zoals bestand, ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Het ontwikkelen van een flexibel PHP-loggingsysteem met dynamische logniveaus en meerdere opslagopties vereist een gestructureerde aanpak. Hier is een overzicht van hoe je dit kunt aanpakken, inclusief best practices:
1. Logniveaus definiëren
Gebruik een enumeratie of constante waarden om de logniveaus te definiëren, bijvoorbeeld:
```php
class LogLevel {
const DEBUG = 1;
const INFO = 2;
const WARNING = 3;
const ERROR = 4;
}
```
Of met een array:
```php
$logLevels = [
'debug' => 1,
'info' => 2,
'warning' => 3,
'error' => 4,
];
```
2. Logfunctie structureren
Maak een centrale logfunctie of -klasse die:
- Het logniveau controleert tegen een ingestelde minimale logdrempel.
- De logberichten formatteert (timestamp, niveau, bericht).
- Het logbericht doorstuurt naar de juiste opslagmethode.
Voorbeeld:
```php
class Logger {
private $minLevel;
private $handlers = [];
public function __construct($minLevel = LogLevel::DEBUG) {
$this->minLevel = $minLevel;
}
public function addHandler(callable $handler) {
$this->handlers[] = $handler;
}
public function log($level, $message) {
if ($level < $this->minLevel) {
return; // Negeer berichten onder de drempel
}
$levelName = $this->getLevelName($level);
$timestamp = date('Y-m-d H:i:s');
$formattedMessage = "[$timestamp] [$levelName] $message";
foreach ($this->handlers as $handler) {
$handler($formattedMessage, $level);
}
}
private function getLevelName($level) {
switch ($level) {
case LogLevel::DEBUG: return 'DEBUG';
case LogLevel::INFO: return 'INFO';
case LogLevel::WARNING: return 'WARNING';
case LogLevel::ERROR: return 'ERROR';
default: return 'UNKNOWN';
}
}
}
```
3. Opslagopties configureren
Voor verschillende opslagmethoden kun je handlers maken:
- **Bestand:**
```php
$logger->addHandler(function($message, $level) {
file_put_contents('log.txt', $message.PHP_EOL, FILE_APPEND);
});
```
- **Database:**
Maak een database-tabel (bijvoorbeeld `logs`) en een handler:
```php
$db = new PDO('mysql:host=localhost;dbname=logs', 'user', 'pass');
$logger->addHandler(function($message, $level) use ($db) {
$stmt = $db->prepare("INSERT INTO logs (timestamp, level, message) VALUES (?, ?, ?)");
// Ontleed het bericht om timestamp, level, message te scheiden of voeg direct toe
$stmt->execute([date('Y-m-d H:i:s'), $level, $message]);
});
```
- **Cloudopslag (bijvoorbeeld AWS S3):**
Gebruik een SDK of API om logs naar cloud te sturen, bijvoorbeeld:
```php
// Pseudocode voor S3
$s3Client->putObject([
'Bucket' => 'jouw-bucket',
'Key' => 'logs/log_' . date('Y-m-d') . '.txt',
'Body' => $message . PHP_EOL,
]);
```
4. Logniveaus dynamisch instellen en aanpassen
Stel de minimale logdrempel in via configuratie of omgeving:
```php
$logger = new Logger($configuredMinLevel);
```
Je kunt ook logniveaus per handler configureren, bijvoorbeeld door verschillende handlers met verschillende drempels toe te voegen.
5. Best practices voor logbeheer en ophalen
- **Rotatie en archivering:** Wissel logbestanden regelmatig of gebruik logrotate.
- **Filtering:** Implementeer filters op niveau of component.
- **Beveiliging:** Zorg dat logs niet toegankelijk zijn voor onbevoegden.
- **Opslag en back-up:** Bewaar logs langdurig, vooral bij foutopsporing.
- **Analyseren:** Gebruik tools of scripts om logs te doorzoeken en rapporten te genereren.
Voor ophalen:
- Lees logs uit bestanden met `file_get_contents()` of streams.
- Query logs uit database met SQL.
- Gebruik zoek- en filtermechanismen om relevante logs te vinden.
**Samenvatting**:
Door een centrale `Logger`-klasse te maken met configureerbare logniveaus en meerdere handlers, creëer je een flexibel systeem. Zorg voor goede logrotatie, beveiliging, en eenvoudige manieren om logs te bekijken en te analyseren.
Heeft u specifieke wensen of vragen over implementatie of integratie?
provider: deepseek
model: deepseek-chat
Hier is een uitgebreide uitleg voor het bouwen van een flexibel PHP-loggingsysteem:
## Basisstructuur Logfunctie
```php
<?php
class Logger {
const DEBUG = 100;
const INFO = 200;
const WAARSCHUWING = 300;
const FOUT = 400;
private $huidigNiveau;
private $opslagHandlers;
public function __construct($niveau = self::INFO) {
$this->huidigNiveau = $niveau;
$this->opslagHandlers = [];
}
public function log($niveau, $bericht, $context = []) {
if ($niveau < $this->huidigNiveau) {
return;
}
$logEntry = [
'timestamp' => date('Y-m-d H:i:s'),
'niveau' => $this->getNiveauNaam($niveau),
'bericht' => $bericht,
'context' => $context
];
foreach ($this->opslagHandlers as $handler) {
$handler->opslaan($logEntry);
}
}
private function getNiveauNaam($niveau) {
$niveaus = [
self::DEBUG => 'DEBUG',
self::INFO => 'INFO',
self::WAARSCHUWING => 'WAARSCHUWING',
self::FOUT => 'FOUT'
];
return $niveaus[$niveau] ?? 'ONBEKEND';
}
// Helper methodes voor verschillende niveaus
public function debug($bericht, $context = []) {
$this->log(self::DEBUG, $bericht, $context);
}
public function info($bericht, $context = []) {
$this->log(self::INFO, $bericht, $context);
}
public function waarschuwing($bericht, $context = []) {
$this->log(self::WAARSCHUWING, $bericht, $context);
}
public function fout($bericht, $context = []) {
$this->log(self::FOUT, $bericht, $context);
}
}
```
## Opslag Handlers
### Bestandsopslag
```php
class BestandOpslag {
private $bestandPad;
public function __construct($bestandPad) {
$this->bestandPad = $bestandPad;
}
public function opslaan($logEntry) {
$logRegel = sprintf(
"[%s] %s: %s %s\n",
$logEntry['timestamp'],
$logEntry['niveau'],
$logEntry['bericht'],
!empty($logEntry['context']) ? json_encode($logEntry['context']) : ''
);
file_put_contents($this->bestandPad, $logRegel, FILE_APPEND | LOCK_EX);
}
}
```
### Databaseopslag
```php
class DatabaseOpslag {
private $pdo;
public function __construct(PDO $pdo) {
$this->pdo = $pdo;
$this->creerTabelIndienNodig();
}
private function creerTabelIndienNodig() {
$query = "CREATE TABLE IF NOT EXISTS logs (
id INT AUTO_INCREMENT PRIMARY KEY,
timestamp DATETIME,
niveau VARCHAR(20),
bericht TEXT,
context JSON,
INDEX idx_timestamp (timestamp),
INDEX idx_niveau (niveau)
)";
$this->pdo->exec($query);
}
public function opslaan($logEntry) {
$query = "INSERT INTO logs (timestamp, niveau, bericht, context)
VALUES (:timestamp, :niveau, :bericht, :context)";
$stmt = $this->pdo->prepare($query);
$stmt->execute([
':timestamp' => $logEntry['timestamp'],
':niveau' => $logEntry['niveau'],
':bericht' => $logEntry['bericht'],
':context' => json_encode($logEntry['context'])
]);
}
}
```
### Cloudopslag (AWS S3 voorbeeld)
```php
class S3Opslag {
private $s3Client;
private $bucket;
public function __construct($s3Client, $bucket) {
$this->s3Client = $s3Client;
$this->bucket = $bucket;
}
public function opslaan($logEntry) {
$logBestand = 'logs/' . date('Y-m-d') . '.log';
$logRegel = json_encode($logEntry) . "\n";
// Upload naar S3 (vereist AWS SDK)
$this->s3Client->putObject([
'Bucket' => $this->bucket,
'Key' => $logBestand,
'Body' => $logRegel,
'ACL' => 'private'
]);
}
}
```
## Configuratie en Gebruik
```php
// Logger configureren
$logger = new Logger(Logger::DEBUG);
// Meerdere opslagmethoden toevoegen
$logger->voegOpslagToe(new BestandOpslag('/pad/naar/logbestand.log'));
$logger->voegOpslagToe(new DatabaseOpslag($pdo));
// $logger->voegOpslagToe(new S3Opslag($s3Client, 'mijn-bucket'));
// Gebruik
$logger->info('Gebruiker ingelogd', ['gebruiker_id' => 123, 'ip' => '192.168.1.1']);
$logger->fout('Database connectie gefaald', ['error' => $e->getMessage()]);
```
## Beste Praktijken
### 1. Logniveau Beheer
```php
// Configuratie via omgevingsvariabelen
$logNiveau = getenv('APP_LOG_LEVEL') ?: Logger::INFO;
$logger = new Logger($logNiveau);
// Productie vs ontwikkeling
if (getenv('APP_ENV') === 'production') {
$logger->setNiveau(Logger::WAARSCHUWING);
} else {
$logger->setNiveau(Logger::DEBUG);
}
```
### 2. Log Rotatie
```php
class RoterendBestandOpslag extends BestandOpslag {
private $maxGrootte;
public function __construct($bestandPad, $maxGrootte = 10485760) { // 10MB
parent::__construct($bestandPad);
$this->maxGrootte = $maxGrootte;
}
public function opslaan($logEntry) {
if (file_exists($this->bestandPad) &&
filesize($this->bestandPad) >= $this->maxGrootte) {
$this->roteer();
}
parent::opslaan($logEntry);
}
private function roteer() {
$oudeBestand = $this->bestandPad . '.' . date('Y-m-d_His');
rename($this->bestandPad, $oudeBestand);
}
}
```
### 3. Log Ophalen en Analyseren
```php
class LogQuery {
private $pdo;
public function __construct(PDO $pdo) {
$this->pdo = $pdo;
}
public function zoek($criteria = []) {
$where = [];
$params = [];
if (!empty($criteria['niveau'])) {
$where[] = 'niveau = :niveau';
$params[':niveau'] = $criteria['niveau'];
}
if (!empty($criteria['vanaf'])) {
$where[] = 'timestamp >= :vanaf';
$params[':vanaf'] = $criteria['vanaf'];
}
if (!empty($criteria['tot'])) {
$where[] = 'timestamp <= :tot';
$params[':tot'] = $criteria['tot'];
}
$query = "SELECT * FROM logs";
if (!empty($where)) {
$query .= " WHERE " . implode(' AND ', $where);
}
$query .= " ORDER BY timestamp DESC LIMIT 1000";
$stmt = $this->pdo->prepare($query);
$stmt->execute($params);
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}
```
### 4. Beveiliging en Prestaties
```php
// Gevoelige data filteren
class VeiligeLogger extends Logger {
public function log($niveau, $bericht, $context = []) {
$context = $this->filterGevoeligeData($context);
parent::log($niveau, $bericht, $context);
}
private function filterGevoeligeData($context) {
$gevoeligeVelden = ['wachtwoord', 'token', 'api_key', 'creditcard'];
foreach ($gevoeligeVelden as $veld) {
if (isset($context[$veld])) {
$context[$veld] = '***VERBORGEN***';
}
}
return $context;
}
}
// Asynchrone logging voor betere prestaties
class AsynchroneOpslag {
public function opslaan($logEntry) {
// Plaats in queue voor later verwerking
// Gebruik Redis, RabbitMQ, of database queue
}
}
```
## Gebruiksvoorbeeld Compleet Systeem
```php
// Initialisatie
$logger = new VeiligeLogger(Logger::DEBUG);
// Verschillende opslagmethoden
$logger->voegOpslagToe(new RoterendBestandOpslag('/var/log/mijn-app.log'));
$logger->voegOpslagToe(new DatabaseOpslag($pdo));
// Loggen met context
try {
$logger->info('API verzoek ontvangen', [
'method' => $_SERVER['REQUEST_METHOD'],
'endpoint' => $_SERVER['REQUEST_URI'],
'user_agent' => $_SERVER['HTTP_USER_AGENT']
]);
// Je applicatielogica hier
$logger->info('API verzoek succesvol afgerond');
} catch (Exception $e) {
$logger->fout('API verzoek gefaald', [
'error' => $e->getMessage(),
'stack_trace' => $e->getTraceAsString()
]);
}
```
Dit systeem biedt flexibiliteit, schaalbaarheid en voldoet aan enterprise logging standaarden. Pas het aan naar je specifieke behoeften en infrastructuur.