【AI ブロガー開発】最適化とエラーハンドリング

この記事はで読むことができます。

目次非表示

はじめに
1. 並行処理による効率化
2. エラーハンドリングとログ記録の改善
3. リトライメカニズムとバックオフ戦略
4. パフォーマンスモニタリング
まとめ
次のステップ

はじめに

これまでの記事で、Claude APIを使用した記事生成と、WordPress REST APIを利用した自動投稿機能を実装してきました。本記事では、このAIブロガーシステムをより信頼性が高く、効率的なものにするための最適化とエラーハンドリングについて詳しく解説します。

この記事を通じて、以下のスキルと知識を習得することができます。

Golangにおける並行処理とパフォーマンス最適化
堅牢なエラーハンドリングとログ記録の実装
リトライメカニズムとバックオフ戦略の設計
システムのモニタリングと診断

それでは、具体的な実装と最適化手法を見ていきましょう。

1. 並行処理による効率化

複数の記事を同時に生成・投稿することで、システムのスループットを向上させることができます。Golangのgoroutineとchannelを使用して、並行処理を実装しましょう。

cmd/main.goを以下のように更新します。

package main

import (
    "fmt"
    "log"
    "sync"

    "github.com/yourusername/ai-blogger-golang/config"
    "github.com/yourusername/ai-blogger-golang/internal/claude"
    "github.com/yourusername/ai-blogger-golang/internal/content"
    "github.com/yourusername/ai-blogger-golang/internal/wordpress"
)

func main() {
    cfg, err := config.Load()
    if err != nil {
        log.Fatalf("Error loading config: %v", err)
    }

    claudeClient := claude.NewClient(cfg.ClaudeAPIKey)
    generator := content.NewGenerator(claudeClient)
    wpClient := wordpress.NewClient(cfg.WordPressBaseURL, cfg.WordPressUsername, cfg.WordPressPassword)

    keywords := []string{"人工知能", "機械学習", "ディープラーニング", "自然言語処理", "コンピュータビジョン"}
    categoryName := "技術"

    var wg sync.WaitGroup
    results := make(chan string, len(keywords))

    for _, keyword := range keywords {
        wg.Add(1)
        go func(kw string) {
            defer wg.Done()
            if err := generateAndPostArticle(generator, wpClient, kw, categoryName); err != nil {
                results <- fmt.Sprintf("Error processing %s: %v", kw, err)
            } else {
                results <- fmt.Sprintf("Successfully processed %s", kw)
            }
        }(keyword)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for result := range results {
        fmt.Println(result)
    }
}

func generateAndPostArticle(generator *content.Generator, wpClient *wordpress.Client, keyword, categoryName string) error {
    article, err := generator.GenerateArticle(keyword)
    if err != nil {
        return fmt.Errorf("error generating article: %v", err)
    }

    categories, err := wpClient.GetCategories()
    if err != nil {
        return fmt.Errorf("error getting categories: %v", err)
    }

    var categoryID int
    for _, category := range categories {
        if category.Name == categoryName {
            categoryID = category.ID
            break
        }
    }

    if categoryID == 0 {
        return fmt.Errorf("category not found: %s", categoryName)
    }

    postID, err := wpClient.CreatePost(article, []int{categoryID})
    if err != nil {
        return fmt.Errorf("error posting to WordPress: %v", err)
    }

    log.Printf("Article '%s' successfully posted with ID: %d\n", article.Title, postID)
    return nil
}

この実装では、各キーワードに対して並行して記事生成と投稿を行います。これにより、複数の記事を同時に処理することができ、全体的な処理時間を短縮できます。

2. エラーハンドリングとログ記録の改善

エラーが発生した際に、より詳細な情報を記録し、適切に対処するためのエラーハンドリングとログ記録を実装します。

internal/logger/logger.goファイルを新たに作成し、以下の内容を追加します。

package logger

import (
    "log"
    "os"
)

var (
    InfoLogger  *log.Logger
    ErrorLogger *log.Logger
)

func init() {
    InfoLogger = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
    ErrorLogger = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
}

次に、internal/wordpress/client.goのCreatePost関数を更新して、より詳細なエラー情報を提供します。

func (c *Client) CreatePost(article *models.Article, categoryIDs []int) (int, error) {
    // ... (前半部分は変更なし)

    resp, err := client.Do(req)
    if err != nil {
        return 0, fmt.Errorf("error sending request: %v", err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    if resp.StatusCode != http.StatusCreated {
        return 0, fmt.Errorf("unexpected status code: %d, response: %s", resp.StatusCode, string(body))
    }

    var result map[string]interface{}
    if err := json.Unmarshal(body, &result); err != nil {
        return 0, fmt.Errorf("error decoding response: %v, body: %s", err, string(body))
    }

    // ... (後半部分は変更なし)
}

3. リトライメカニズムとバックオフ戦略

一時的なエラーに対処するため、リトライメカニズムとバックオフ戦略を実装します。internal/utils/retry.goファイルを作成し、以下の内容を追加します。

package utils

import (
    "math"
    "time"

    "github.com/yourusername/ai-blogger-golang/internal/logger"
)

func RetryWithExponentialBackoff(operation func() error, maxRetries int) error {
    var err error
    for i := 0; i < maxRetries; i++ {
        err = operation()
        if err == nil {
            return nil
        }

        delay := time.Duration(math.Pow(2, float64(i))) * time.Second
        logger.InfoLogger.Printf("Retry %d failed, retrying in %v: %v", i+1, delay, err)
        time.Sleep(delay)
    }
    return err
}

この関数を使用して、WordPressへの投稿処理にリトライ機能を追加します。internal/wordpress/client.goのCreatePost関数を以下のように更新します。

func (c *Client) CreatePost(article *models.Article, categoryIDs []int) (int, error) {
    var postID int
    err := utils.RetryWithExponentialBackoff(func() error {
        var err error
        postID, err = c.createPostOnce(article, categoryIDs)
        return err
    }, 3)
    return postID, err
}

func (c *Client) createPostOnce(article *models.Article, categoryIDs []int) (int, error) {
    // 元のCreatePost関数の内容をここに移動
}

4. パフォーマンスモニタリング

システムのパフォーマンスを監視するため、簡単なメトリクス収集機能を実装します。internal/metrics/metrics.goファイルを作成し、以下の内容を追加します。

package metrics

import (
    "sync"
    "time"
)

type Metrics struct {
    mu                sync.Mutex
    articleGenerated  int
    articlePosted     int
    totalProcessingTime time.Duration
}

var globalMetrics = &Metrics{}

func IncrementArticleGenerated() {
    globalMetrics.mu.Lock()
    defer globalMetrics.mu.Unlock()
    globalMetrics.articleGenerated++
}

func IncrementArticlePosted() {
    globalMetrics.mu.Lock()
    defer globalMetrics.mu.Unlock()
    globalMetrics.articlePosted++
}

func AddProcessingTime(duration time.Duration) {
    globalMetrics.mu.Lock()
    defer globalMetrics.mu.Unlock()
    globalMetrics.totalProcessingTime += duration
}

func GetMetrics() (int, int, time.Duration) {
    globalMetrics.mu.Lock()
    defer globalMetrics.mu.Unlock()
    return globalMetrics.articleGenerated, globalMetrics.articlePosted, globalMetrics.totalProcessingTime
}

これらのメトリクスを使用するようにmain.goを更新します。

func generateAndPostArticle(generator *content.Generator, wpClient *wordpress.Client, keyword, categoryName string) error {
    start := time.Now()
    defer func() {
        metrics.AddProcessingTime(time.Since(start))
    }()

    article, err := generator.GenerateArticle(keyword)
    if err != nil {
        return fmt.Errorf("error generating article: %v", err)
    }
    metrics.IncrementArticleGenerated()

    // ... (中略)

    postID, err := wpClient.CreatePost(article, []int{categoryID})
    if err != nil {
        return fmt.Errorf("error posting to WordPress: %v", err)
    }
    metrics.IncrementArticlePosted()

    // ... (後略)
}

func main() {
    // ... (前略)

    for result := range results {
        fmt.Println(result)
    }

    generated, posted, totalTime := metrics.GetMetrics()
    fmt.Printf("Total articles generated: %d\n", generated)
    fmt.Printf("Total articles posted: %d\n", posted)
    fmt.Printf("Total processing time: %v\n", totalTime)
}