Implementing Error Handling and Retries in Go for Whisper API

Welcome back! In the previous lesson, you learned how to make your first Whisper API request to transcribe audio using Go. Now, let's make your transcription system more robust by adding error handling and retry logic. This lesson will show you how to handle errors explicitly and retry failed API requests, ensuring your application can recover gracefully from temporary issues like network interruptions or server timeouts.

In Go, error handling is done explicitly by returning error values from functions. Instead of exceptions or decorators, Go uses control structures like loops and helper functions to implement retry logic. This approach gives you clear control over how errors are handled and when to retry operations.

In real-world applications, errors can occur for many reasons — network hiccups, server downtime, or unexpected glitches. Rather than letting your program fail immediately, it's often better to retry the operation a few times before giving up. This makes your application more resilient and user-friendly.

Go handles errors by returning them as values from functions. You check these errors explicitly and decide how to respond. To implement retries, you typically use a loop that attempts the operation multiple times, waiting between attempts if needed. This pattern is especially important when working with APIs, where transient errors are common.

Let's see how to implement retry logic for the Whisper API transcription function in Go. We'll create a helper function that attempts to transcribe audio, retrying up to a specified number of times with a delay between attempts.

Here's how you can structure this in Go:

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
)

// Transcribe attempts to transcribe an audio file using the Whisper API.
func Transcribe(filePath string) (string, error) {
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL")

    client := openai.NewClient(
        option.WithAPIKey(apiKey),
        option.WithBaseURL(baseURL),
    )

    file, err := os.Open(filePath)
    if err != nil {
        return "", fmt.Errorf("failed to open audio file: %v", err)
    }
    defer file.Close()

    resp, err := client.Audio.Transcriptions.New(
        context.Background(),
        openai.AudioTranscriptionNewParams{
            File:  file,
            Model: "whisper-1",
        },
    )
    if err != nil {
        return "", fmt.Errorf("transcription failed: %v", err)
    }

    return resp.Text, nil
}

Now, let's add a retry helper function:

// TranscribeWithRetry tries to transcribe the audio file up to maxRetries times,
// waiting delay seconds between attempts.
func TranscribeWithRetry(filePath string, maxRetries int, delay time.Duration) (string, error) {
    var lastErr error
    for attempt := 1; attempt <= maxRetries; attempt++ {
        result, err := Transcribe(filePath)
        if err == nil {
            return result, nil
        }
        lastErr = err
        fmt.Printf("Attempt %d failed: %v\n", attempt, err)
        if attempt < maxRetries {
            fmt.Printf("Retrying in %v...\n", delay)
            time.Sleep(delay)
        }
    }
    return "", fmt.Errorf("all %d attempts failed: %v", maxRetries, lastErr)
}

Explanation:

• TranscribeWithRetry calls the Transcribe function in a loop.
• If an error occurs, it prints the error and waits for the specified delay before retrying.
• If all attempts fail, it returns the last error.

Let's see how to use the retry logic in your main program:

func main() {
    filePath := "resources/sample_audio.mp3"
    maxRetries := 3
    delay := 5 * time.Second

    transcription, err := TranscribeWithRetry(filePath, maxRetries, delay)
    if err != nil {
        fmt.Printf("Transcription failed after %d attempts: %v\n", maxRetries, err)
        return
    }
    fmt.Println("Transcription:", transcription)
}

Explanation:

• The main function calls TranscribeWithRetry, specifying the number of retries and the delay between attempts.
• If transcription succeeds, it prints the result.
• If all attempts fail, it prints an error message.

In this lesson, you learned how to make your transcription system more reliable by implementing error handling and retry logic in Go. Go uses explicit error returns, allowing you to check and handle errors directly. By wrapping your API calls in a retry loop or helper function, you can recover from temporary failures and make your application more robust.

This approach is essential when working with APIs, where network issues or server problems can cause occasional failures. By handling errors explicitly and retrying operations when appropriate, you ensure your application remains stable and user-friendly, even in the face of transient issues.