PHP Traits — Fatal Method Collision That Broke API Payments

<?php

trait HasTimestamps {
    private int $createdAtTimestamp;

    public function setCreatedAt(int $timestamp): void {
        $this->createdAtTimestamp = $timestamp;
    }

    public function getCreatedAt(): string {
        return date('Y-m-d H:i:s', $this->createdAtTimestamp);
    }

    public function getTimeAgo(): string {
        $seconds = time() - $this->createdAtTimestamp;
        if ($seconds < 60) return $seconds . ' seconds ago';
        if ($seconds < 3600) return round($seconds / 60) . ' minutes ago';
        if ($seconds < 86400) return round($seconds / 3600) . ' hours ago';
        return round($seconds / 86400) . ' days ago';
    }
}

class BlogPost {
    use HasTimestamps;

    public function __construct(
        private string $title
    ) {
        $this->setCreatedAt(time());
    }

    public function getSummary(): string {
        return "Post: '{$this->title}' — Created: {$this->getCreatedAt()}";
    }
}

class Product {
    use HasTimestamps;

    public function __construct(
        private string $name,
        private float $price
    ) {
        $this->setCreatedAt(time());
    }

    public function getLabel(): string {
        return "{$this->name} (\${$this->price}) — Listed {$this->getTimeAgo()}";
    }
}

$post = new BlogPost('Understanding PHP Traits');
echo $post->getSummary() . PHP_EOL;

$product = new Product('Mechanical Keyboard', 129.99);
echo $product->getLabel() . PHP_EOL;

var_dump($post instanceof BlogPost);
// var_dump($post instanceof HasTimestamps); // Fatal Error

<?php

// Trait for basic console-style logging
trait ConsoleLogger {
    public function log(string $message): void {
        echo '[CONSOLE] ' . $message . PHP_EOL;
    }

    public function formatEntry(string $message): string {
        return strtoupper($message);
    }
}

// Trait for structured JSON-style logging
trait JsonLogger {
    public function log(string $message): void {
        echo json_encode(['level' => 'info', 'message' => $message]) . PHP_EOL;
    }

    public function formatEntry(string $message): string {
        return json_encode(['entry' => $message]);
    }
}

class ApplicationService {
    use ConsoleLogger, JsonLogger {
        JsonLogger::log insteadof ConsoleLogger;
        ConsoleLogger::formatEntry insteadof JsonLogger;
        ConsoleLogger::log as logToConsole;
        ConsoleLogger::formatEntry as protected;
    }

    public function processOrder(int $orderId): void {
        $this->log("Processing order #{$orderId}");
        $this->logToConsole("Also logging order #{$orderId} to console");
    }
}

$service = new ApplicationService();
$service->processOrder(1042);

echo PHP_EOL;

trait SoftDeletes {
    private bool $isDeleted = false;

    public function softDelete(): void {
        $this->isDeleted = true;
    }

    public function isDeleted(): bool {
        return $this->isDeleted;
    }

    public function restore(): void {
        $this->isDeleted = false;
    }
}

trait HasSlug {
    private string $slug = '';

    public function setSlug(string $title): void {
        $this->slug = strtolower(str_replace(' ', '-', preg_replace('/[^a-zA-Z0-9 ]/', '', $title)));
    }

    public function getSlug(): string {
        return $this->slug;
    }
}

class Article {
    use SoftDeletes, HasSlug;

    public function __construct(private string $title) {
        $this->setSlug($title);
    }
}

$article = new Article('How to Use PHP Traits Effectively');
echo 'Slug: ' . $article->getSlug() . PHP_EOL;
echo 'Deleted? ' . ($article->isDeleted() ? 'Yes' : 'No') . PHP_EOL;

$article->softDelete();
echo 'After delete — Deleted? ' . ($article->isDeleted() ? 'Yes' : 'No') . PHP_EOL;

$article->restore();
echo 'After restore — Deleted? ' . ($article->isDeleted() ? 'Yes' : 'No') . PHP_EOL;

<?php

trait LogsActivity {
    abstract protected function getLogChannel(): string;
    abstract protected function getActivityContext(): array;

    public function logActivity(string $action): void {
        $channel = $this->getLogChannel();
        $context = $this->getActivityContext();

        $logEntry = [
            'channel'   => $channel,
            'action'    => $action,
            'context'   => $context,
            'timestamp' => date('Y-m-d H:i:s'),
        ];

        echo '[LOG:' . strtoupper($channel) . '] '
            . $action
            . ' | Context: ' . json_encode($context)
            . PHP_EOL;
    }
}

class PaymentProcessor {
    use LogsActivity;

    public function __construct(
        private string $merchantId,
        private string $gateway
    ) {}

    protected function getLogChannel(): string {
        return 'payments';
    }

    protected function getActivityContext(): array {
        return [
            'merchant_id' => $this->merchantId,
            'gateway'     => $this->gateway,
        ];
    }

    public function charge(float $amount, string $currency): void {
        $this->logActivity("Charged {$amount} {$currency}");
    }
}

class UserAuthenticator {
    use LogsActivity;

    public function __construct(private string $userId) {}

    protected function getLogChannel(): string {
        return 'auth';
    }

    protected function getActivityContext(): array {
        return ['user_id' => $this->userId];
    }

    public function login(string $ipAddress): void {
        $this->logActivity("User logged in from {$ipAddress}");
    }

    public function logout(): void {
        $this->logActivity('User logged out');
    }
}

$processor = new PaymentProcessor('MERCH-882', 'Stripe');
$processor->charge(49.99, 'USD');
$processor->charge(149.00, 'USD');

echo PHP_EOL;

$auth = new UserAuthenticator('USR-4421');
$auth->login('192.168.1.55');
$auth->logout();

<?php

interface Auditable {
    public function getAuditLog(): array;
    public function recordChange(string $field, mixed $oldValue, mixed $newValue): void;
}

trait AuditableTrait {
    private array $auditLog = [];

    public function recordChange(string $field, mixed $oldValue, mixed $newValue): void {
        $this->auditLog[] = [
            'field'      => $field,
            'old_value'  => $oldValue,
            'new_value'  => $newValue,
            'changed_at' => date('H:i:s'),
        ];
    }

    public function getAuditLog(): array {
        return $this->auditLog;
    }
}

class InvoiceOrder implements Auditable {
    use AuditableTrait;

    private float $total;
    private string $status;

    public function __construct(
        private int $invoiceId,
        float $initialTotal
    ) {
        $this->total  = $initialTotal;
        $this->status = 'draft';
    }

    public function updateTotal(float $newTotal): void {
        $this->recordChange('total', $this->total, $newTotal);
        $this->total = $newTotal;
    }

    public function updateStatus(string $newStatus): void {
        $this->recordChange('status', $this->status, $newStatus);
        $this->status = $newStatus;
    }
}

function printAuditReport(Auditable $entity): void {
    $log = $entity->getAuditLog();
    if (empty($log)) {
        echo 'No changes recorded.' . PHP_EOL;
        return;
    }
    foreach ($log as $index => $entry) {
        echo sprintf(
            "[%d] Field '%s': '%s' → '%s' at %s\n",
            $index + 1,
            $entry['field'],
            $entry['old_value'],
            $entry['new_value'],
            $entry['changed_at']
        );
    }
}

$invoice = new InvoiceOrder(invoiceId: 5501, initialTotal: 250.00);
$invoice->updateTotal(275.50);
$invoice->updateStatus('sent');
$invoice->updateTotal(260.00);
$invoice->updateStatus('paid');

echo "=== Audit Report for Invoice #5501 ===" . PHP_EOL;
printAuditReport($invoice);

var_dump($invoice instanceof Auditable);

<?php

// Problematic: trait with I/O that can't be mocked
interface LoggerInterface {
    public function log(string $message): void;
}

class FileLogger implements LoggerInterface {
    public function log(string $message): void {
        file_put_contents('/tmp/app.log', $message . PHP_EOL, FILE_APPEND);
    }
}

// Trait that logs via a concrete class — tightly coupled
trait HasLogger {
    public function doSomething(): void {
        // hardcoded dependency — can't swap for testing
        $logger = new FileLogger();
        $logger->log('Something happened');
    }
}

// Better approach: inject logger
class InjectableService {
    public function __construct(
        private LoggerInterface $logger
    ) {}

    public function doSomething(): void {
        $this->logger->log('Something happened');
    }
}

// Test passes a mock
$mockLogger = $this->createMock(LoggerInterface::class);
$service = new InjectableService($mockLogger);

// io.thecodeforge — php tutorial

trait AuditTrail {
    public function logChange(string $action): void {
        // Stateless: no properties, just behavior
        $entry = sprintf(
            '[%s] User %s performed %s on %s',
            date('Y-m-d H:i:s'),
            $_SESSION['user_id'] ?? 'anonymous',
            $action,
            static::class
        );
        file_put_contents('/var/log/audit.log', $entry . PHP_EOL, FILE_APPEND);
    }
}

class OrderProcessor {
    use AuditTrail;
    
    public function fulfill(int $orderId): void {
        // business logic...
        $this->logChange("fulfilled order #{$orderId}");
    }
}

class InvoiceGenerator {
    use AuditTrail;
    
    public function generate(int $invoiceId): void {
        // more logic...
        $this->logChange("generated invoice #{$invoiceId}");
    }
}

$processor = new OrderProcessor();
$processor->fulfill(42);

echo "Check /var/log/audit.log for entries.\n";

// io.thecodeforge — php tutorial

trait Logger {
    public function log(string $msg): void {
        echo "[Logger] $msg\n";
    }
}

trait Notifier {
    public function log(string $msg): void {
        echo "[Notifier] $msg\n";
    }
}

class PaymentGateway {
    use Logger, Notifier {
        // Keep Logger's log() as default
        Logger::log insteadof Notifier;
        // But alias Notifier's log() as notifyLog()
        Notifier::log as notifyLog;
        // Bonus: make notifyLog private to hide it
        // Notifier::log as private notifyLog;
    }
    
    public function process(float $amount): void {
        $this->log("Processing payment: \${$amount}");
        $this->notifyLog("Payment received: \${$amount}");
    }
}

$gw = new PaymentGateway();
$gw->process(99.99);