121 lines
3.3 KiB
Go
121 lines
3.3 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"mal/internal/db"
|
|
"mal/internal/domain"
|
|
"mal/internal/observability"
|
|
)
|
|
|
|
func (s *EpisodeService) providerID(ctx context.Context, anime domain.Anime, provider domain.EpisodeAvailabilityProvider, titles []string) (string, error) {
|
|
providerID, found, err := s.cachedProviderID(ctx, anime, provider)
|
|
if found || err != nil {
|
|
return providerID, err
|
|
}
|
|
|
|
providerID, err = provider.ResolveEpisodeProviderID(ctx, anime.MalID, titles)
|
|
if err != nil {
|
|
s.cacheProviderIDFailure(ctx, anime, provider, err)
|
|
return "", err
|
|
}
|
|
|
|
s.cacheProviderIDSuccess(ctx, anime, provider, providerID)
|
|
observability.Info(
|
|
"episodes_provider_id_resolved",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"provider": provider.Name(),
|
|
"provider_id": providerID,
|
|
},
|
|
)
|
|
return providerID, nil
|
|
}
|
|
|
|
func (s *EpisodeService) cachedProviderID(ctx context.Context, anime domain.Anime, provider domain.EpisodeAvailabilityProvider) (string, bool, error) {
|
|
row, err := s.queries.GetEpisodeProviderMapping(ctx, db.GetEpisodeProviderMappingParams{
|
|
AnimeID: int64(anime.MalID),
|
|
Provider: provider.Name(),
|
|
})
|
|
if err != nil {
|
|
s.metrics.ObserveCache("episode_provider_mapping", "miss")
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return "", false, nil
|
|
}
|
|
observability.Warn(
|
|
"episodes_provider_id_cache_read_failed",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"provider": provider.Name(),
|
|
},
|
|
err,
|
|
)
|
|
return "", false, nil
|
|
}
|
|
|
|
if row.FailedUntil.Valid && row.FailedUntil.Time.After(s.clock.Now()) {
|
|
s.metrics.ObserveCache("episode_provider_mapping", "hit")
|
|
return "", true, fmt.Errorf("cached provider mapping failure active until %s: %s", row.FailedUntil.Time.Format(time.RFC3339), row.LastError)
|
|
}
|
|
if strings.TrimSpace(row.ProviderShowID) == "" {
|
|
s.metrics.ObserveCache("episode_provider_mapping", "miss")
|
|
return "", false, nil
|
|
}
|
|
|
|
s.metrics.ObserveCache("episode_provider_mapping", "hit")
|
|
observability.Info(
|
|
"episodes_provider_id_cache_hit",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"provider": provider.Name(),
|
|
"provider_id": row.ProviderShowID,
|
|
},
|
|
)
|
|
return row.ProviderShowID, true, nil
|
|
}
|
|
|
|
func (s *EpisodeService) cacheProviderIDFailure(ctx context.Context, anime domain.Anime, provider domain.EpisodeAvailabilityProvider, resolveErr error) {
|
|
_ = s.queries.UpsertEpisodeProviderMapping(ctx, db.UpsertEpisodeProviderMappingParams{
|
|
AnimeID: int64(anime.MalID),
|
|
Provider: provider.Name(),
|
|
ProviderShowID: "",
|
|
FailedUntil: sql.NullTime{Time: s.clock.Now().Add(time.Hour), Valid: true},
|
|
LastError: truncate(resolveErr.Error(), 400),
|
|
})
|
|
}
|
|
|
|
func (s *EpisodeService) cacheProviderIDSuccess(ctx context.Context, anime domain.Anime, provider domain.EpisodeAvailabilityProvider, providerID string) {
|
|
err := s.queries.UpsertEpisodeProviderMapping(ctx, db.UpsertEpisodeProviderMappingParams{
|
|
AnimeID: int64(anime.MalID),
|
|
Provider: provider.Name(),
|
|
ProviderShowID: providerID,
|
|
FailedUntil: sql.NullTime{},
|
|
LastError: "",
|
|
})
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
observability.Warn(
|
|
"episodes_provider_id_cache_write_failed",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"provider": provider.Name(),
|
|
},
|
|
err,
|
|
)
|
|
}
|