Caching Strategy

Why Caching?

Mi API BCV implements an intelligent caching strategy to:

Reduce database queries: Avoid hitting the database on every API request
Improve response times: Serve cached data in milliseconds instead of querying
Minimize resource usage: Lower CPU and database load on high-traffic scenarios
Provide consistency: Same data for all requests within the cache window

Cache Implementation

Cache Configuration

By default, Mi API BCV uses database caching as configured in .env:

.env

CACHE_STORE=database

Other supported cache drivers:

file - File-based caching
redis - Redis (requires Redis server)
memcached - Memcached (requires Memcached server)
database - Database table (default, no additional setup needed)

Cache Duration

All cached data has a 1-hour TTL (Time To Live):

app/Http/Controllers/Api/ScraperController.php

$cacheKey = 'tasas_bancos_' . now()->toDateString();

$records = Cache::remember($cacheKey, 3600, function () {
    return ReferenceRecord::where('date', now()->toDateString())
        ->get()
        ->keyBy('source');
});

Why 1 hour?

Exchange rates don’t change frequently during the day
Balances freshness with performance
Scheduled updates run multiple times, ensuring fresh data

Cache Keys

Cache keys are date-based to ensure proper isolation:

'tasas_bancos_' . now()->toDateString()
// Example: 'tasas_bancos_2026-03-04'

This means:

Each date has its own cache entry
Historical queries get their own cache
Today’s data is cached separately from yesterday’s

Example Cache Keys

Today’s rates: tasas_bancos_2026-03-04
Yesterday’s rates: tasas_bancos_2026-03-03
Specific date: tasas_bancos_2026-03-01

Cache Flow

API Request Received

Client makes a request to / or /info/{date}/{source?}

Generate Cache Key

Controller generates a cache key based on the requested date:

$cacheKey = 'tasas_bancos_' . $queryDate;

Check Cache

Laravel checks if the key exists in cache:

Cache::remember($cacheKey, 3600, function () {
    // This closure only runs if cache misses
    return ReferenceRecord::where('date', $queryDate)->get();
});

Cache Hit: Return Immediately

If cached data exists and hasn’t expired, return it instantly without touching the database.

Cache Miss: Query Database

If no cached data or it expired:

Query the database
Store the result in cache for 3600 seconds
Return the data

Automatic Cache Invalidation

When new exchange rates are scraped and saved, the cache is automatically invalidated using a model observer:

app/Observers/ReferenceObserver.php

class ReferenceObserver
{
    public function saved(ReferenceRecord $referenceRecord): void
    {
        Cache::forget('tasas_bancos_' . $referenceRecord->date);
    }
    
    public function created(ReferenceRecord $referenceRecord): void
    {
        Cache::forget('tasas_bancos_' . $referenceRecord->date);
    }
    
    public function updated(ReferenceRecord $referenceRecord): void
    {
        Cache::forget('tasas_bancos_' . $referenceRecord->date);
    }
    
    public function deleted(ReferenceRecord $referenceRecord): void
    {
        Cache::forget('tasas_bancos_' . $referenceRecord->date);
    }
}

Observer Registration

The observer is registered using PHP attributes:

app/Models/ReferenceRecord.php

use Illuminate\Database\Eloquent\Attributes\ObservedBy;

#[ObservedBy([ReferenceObserver::class])]
class ReferenceRecord extends Model
{
    //
}

This approach ensures cache consistency without manual cache management in controllers or commands.

Cache Warming

The system implements cache warming through the scheduled rates:update command:

routes/console.php

$schedules = [
    '00:00', '00:30', '02:00', '03:00', '03:30', '04:00',
    '05:00', '05:30', '06:30', '07:00', '07:30'
];

foreach ($schedules as $time) {
    Schedule::command('rates:update')->dailyAt($time);
}

How it works:

Command fetches fresh rates from banks
New records are saved to database
Observer automatically invalidates old cache
Next API request rebuilds cache with fresh data

This “warm cache” strategy ensures the first request after an update gets fresh data and caches it for subsequent requests.

Cache Performance

Without Cache

Request → Controller → Database Query → Process Results → Response
Average: ~50-100ms

With Cache (Hit)

Request → Controller → Cache Retrieve → Response
Average: ~5-10ms

Performance improvement: ~10x faster response times

Cache Operations

Viewing Cache Contents

For debugging, you can inspect cache contents using tinker:

php artisan tinker

Cache::get('tasas_bancos_2026-03-04');

Manually Clearing Cache

# Clear all cache
php artisan cache:clear

# Clear specific key in tinker
php artisan tinker
Cache::forget('tasas_bancos_2026-03-04');

Checking Cache Driver

php artisan tinker
config('cache.default');

Advanced Caching Strategies

Using Redis for Better Performance

For high-traffic applications, switch to Redis:

Install Redis

sudo apt-get install redis-server  # Ubuntu/Debian
brew install redis                 # macOS

Install PHP Redis Extension

pecl install redis

Update .env

CACHE_STORE=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

Clear Config Cache

php artisan config:clear

Cache Tags (Redis/Memcached only)

If using Redis, you can implement cache tags for better organization:

// Tag-based caching
Cache::tags(['rates', 'bcv'])->remember($cacheKey, 3600, function () {
    return ReferenceRecord::where('source', 'bcv')->get();
});

// Clear all rate caches
Cache::tags(['rates'])->flush();

Cache tags are NOT supported with file or database drivers. Only use with Redis or Memcached.

Cache Best Practices

1. Use Date-Based Keys

Always include the date in cache keys to prevent data from different days mixing:

// Good
$cacheKey = 'tasas_bancos_' . $date;

// Bad
$cacheKey = 'tasas_bancos';

2. Set Appropriate TTL

1 hour is ideal for exchange rates, but adjust based on your needs:

// 1 hour (current)
Cache::remember($key, 3600, $callback);

// 30 minutes
Cache::remember($key, 1800, $callback);

// 1 day
Cache::remember($key, 86400, $callback);

3. Handle Cache Failures Gracefully

try {
    $data = Cache::remember($key, 3600, function () {
        return ReferenceRecord::where('date', $date)->get();
    });
} catch (\Exception $e) {
    // Fallback to direct database query
    $data = ReferenceRecord::where('date', $date)->get();
    Log::warning('Cache failure', ['error' => $e->getMessage()]);
}

4. Monitor Cache Hit Ratio

Track cache effectiveness:

// Log cache hits and misses
Log::info('Cache check', [
    'key' => $cacheKey,
    'hit' => Cache::has($cacheKey)
]);

Troubleshooting

Cache not working

Check your cache configuration:

php artisan config:cache
php artisan cache:clear

Verify CACHE_STORE in .env matches your setup.

Stale data being served

Cache may not be invalidating properly. Check:

Is the observer registered?
Are database writes actually saving?
Try manual cache clear:

php artisan cache:clear

Cache table doesn't exist

Run migrations to create the cache table:

php artisan migrate

The 0001_01_01_000001_create_cache_table migration creates it.

Redis connection errors

Ensure Redis is running:

redis-cli ping
# Should return: PONG

Check connection settings in .env.

Cache Monitoring

For production environments, monitor cache performance:

// In a custom middleware or service
use Illuminate\Support\Facades\Cache;

class CacheMonitoring
{
    public function logCacheStats()
    {
        $stats = [
            'driver' => config('cache.default'),
            'keys' => Cache::getStore()->getKeys(), // Driver-specific
        ];
        
        Log::info('Cache stats', $stats);
    }
}

Summary

Mi API BCV’s caching strategy:

1-hour TTL balances freshness and performance
Date-based keys ensure data isolation
Automatic invalidation via model observers
Database driver for simple setup (switchable to Redis)
Cache warming through scheduled commands
~10x performance improvement on cache hits

Get Started

Core Concepts

Guides

Why Caching?

Cache Implementation

Cache Configuration

Cache Duration

Cache Keys

Example Cache Keys

Cache Flow

Automatic Cache Invalidation

Observer Registration

Cache Warming

Cache Performance

Without Cache

With Cache (Hit)

Cache Operations

Viewing Cache Contents

Manually Clearing Cache

Checking Cache Driver

Advanced Caching Strategies

Using Redis for Better Performance

Cache Tags (Redis/Memcached only)

Cache Best Practices

1. Use Date-Based Keys

2. Set Appropriate TTL

3. Handle Cache Failures Gracefully

4. Monitor Cache Hit Ratio

Troubleshooting

Cache Monitoring

Summary

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Documentation Index

​Why Caching?

​Cache Implementation

​Cache Configuration

​Cache Duration

​Cache Keys

​Example Cache Keys

​Cache Flow

​Automatic Cache Invalidation

​Observer Registration

​Cache Warming

​Cache Performance

​Without Cache

​With Cache (Hit)

​Cache Operations

​Viewing Cache Contents

​Manually Clearing Cache

​Checking Cache Driver

​Advanced Caching Strategies

​Using Redis for Better Performance

​Cache Tags (Redis/Memcached only)

​Cache Best Practices

​1. Use Date-Based Keys

​2. Set Appropriate TTL

​3. Handle Cache Failures Gracefully

​4. Monitor Cache Hit Ratio

​Troubleshooting

​Cache Monitoring

​Summary

Build docs developers (and LLMs) love

Why Caching?

Cache Implementation

Cache Configuration

Cache Duration

Cache Keys

Example Cache Keys

Cache Flow

Automatic Cache Invalidation

Observer Registration

Cache Warming

Cache Performance

Without Cache

With Cache (Hit)

Cache Operations

Viewing Cache Contents

Manually Clearing Cache

Checking Cache Driver

Advanced Caching Strategies

Using Redis for Better Performance

Cache Tags (Redis/Memcached only)

Cache Best Practices

1. Use Date-Based Keys

2. Set Appropriate TTL

3. Handle Cache Failures Gracefully

4. Monitor Cache Hit Ratio

Troubleshooting

Cache Monitoring

Summary