Caching

// config/artisanpack/analytics.php
'dashboard' => [
    'cache_duration' => env('ANALYTICS_CACHE_DURATION', 300), // 5 minutes
],

'goals' => [
    'cache_duration' => env('ANALYTICS_GOALS_CACHE', 300),
],

analytics:{site_id}:{query_type}:{date_range}:{hash}

use ArtisanPackUI\Analytics\Data\DateRange;

$range = DateRange::last30Days();
$cacheKey = 'my_query_' . $range->toKey();
// my_query_2024-01-01_2024-01-31

use Illuminate\Support\Facades\Cache;
use ArtisanPackUI\Analytics\Data\DateRange;

$range = DateRange::last7Days();
$cacheKey = "custom_stats_{$range->toKey()}";
$cacheDuration = config('artisanpack.analytics.dashboard.cache_duration', 300);

$stats = Cache::remember($cacheKey, $cacheDuration, function () use ($range) {
    return PageView::whereBetween('created_at', [
        $range->startDate,
        $range->endDate,
    ])->count();
});

use ArtisanPackUI\Analytics\Http\Livewire\Concerns\WithAnalyticsWidget;

class CustomWidget extends Component
{
    use WithAnalyticsWidget;

    public function loadData(): void
    {
        $range = $this->getDateRange();
        $cacheKey = $this->getCacheKey('custom_data');

        $this->data = Cache::remember($cacheKey, 300, function () use ($range) {
            return $this->getAnalyticsQuery()->getStats($range);
        });
    }

    protected function getCacheKey(string $suffix): string
    {
        $range = $this->getDateRange();
        $siteId = $this->siteId ?? 'global';

        return "analytics:{$siteId}:{$suffix}:{$range->toKey()}";
    }
}

php artisan analytics:clear-cache

use Illuminate\Support\Facades\Cache;

// Clear specific key
Cache::forget('analytics:1:stats:2024-01-01_2024-01-31:abc123');

// Clear by tag (if using tagged cache)
Cache::tags(['analytics', 'site_1'])->flush();

use ArtisanPackUI\Analytics\Events\PageViewRecorded;

Event::listen(PageViewRecorded::class, function ($event) {
    // Clear real-time cache
    Cache::forget("analytics:{$event->pageView->site_id}:realtime");
});

// .env
CACHE_DRIVER=redis

// config/cache.php
'stores' => [
    'analytics' => [
        'driver' => 'redis',
        'connection' => 'analytics',
    ],
],

Cache::store('analytics')->remember($key, $duration, $callback);

use Illuminate\Support\Facades\Cache;

// Store with tags
Cache::tags(['analytics', 'site_1', 'stats'])
    ->remember($key, 300, $callback);

// Clear by tag
Cache::tags(['site_1'])->flush();
Cache::tags(['stats'])->flush();

'dashboard' => [
    'realtime_interval' => 30, // Refresh every 30 seconds
],

use ArtisanPackUI\Analytics\Services\AnalyticsQuery;

$query = app(AnalyticsQuery::class);

// This result is automatically cached
$stats = $query->getStats($range);

// Force fresh data (bypass cache)
$query->withoutCache();
$freshStats = $query->getStats($range);

// In a scheduled command
use ArtisanPackUI\Analytics\Services\AnalyticsQuery;
use ArtisanPackUI\Analytics\Data\DateRange;
use ArtisanPackUI\Analytics\Models\Site;

class WarmAnalyticsCache extends Command
{
    protected $signature = 'analytics:warm-cache';

    public function handle(AnalyticsQuery $query): void
    {
        $ranges = [
            DateRange::today(),
            DateRange::last7Days(),
            DateRange::last30Days(),
        ];

        Site::active()->each(function ($site) use ($query, $ranges) {
            foreach ($ranges as $range) {
                $query->forSite($site->id)->getStats($range);
                $query->forSite($site->id)->getTopPages($range);
            }
        });

        $this->info('Cache warmed successfully');
    }
}

// routes/console.php
Schedule::command('analytics:warm-cache')->hourly();

// Frequently changing (real-time): 30 seconds
'realtime_interval' => 30,

// Dashboard stats: 5 minutes
'cache_duration' => 300,

// Historical reports: 1 hour
'historical_cache' => 3600,

// Bad: Caching raw database results
$rows = Cache::remember('all_pageviews', 300, function () {
    return PageView::all(); // Too much data
});

// Good: Caching computed results
$stats = Cache::remember('pageview_count', 300, function () {
    return PageView::count(); // Just the number
});

// Store with meaningful tags
Cache::tags(['analytics', "site_{$siteId}", 'daily_stats'])
    ->put($key, $data, 300);

// Invalidate all site data on significant changes
Cache::tags(["site_{$siteId}"])->flush();

$stats = Cache::lock("analytics_lock_{$key}", 10)->block(5, function () use ($key) {
    return Cache::remember($key, 300, function () {
        return $this->expensiveQuery();
    });
});

// Log cache hits/misses
Cache::macro('rememberWithLogging', function ($key, $ttl, $callback) {
    $start = microtime(true);
    $hit = Cache::has($key);

    $result = Cache::remember($key, $ttl, $callback);

    Log::debug('Cache access', [
        'key' => $key,
        'hit' => $hit,
        'duration' => microtime(true) - $start,
    ]);

    return $result;
});