Go言語でのエラーメッセージ出力制御と情報漏洩防止の実践ガイド

type error interface {
    Error() string
}

import "errors"

func exampleFunction() error {
    return errors.New("an example error occurred")
}

func main() {
    err := exampleFunction()
    if err != nil {
        // エラー処理
        fmt.Println("Error:", err)
    }
}

import (
    "errors"
    "fmt"
)

func main() {
    baseErr := errors.New("base error")
    wrappedErr := fmt.Errorf("wrapped error: %w", baseErr)

    // エラーの比較
    if errors.Is(wrappedErr, baseErr) {
        fmt.Println("wrappedErr contains baseErr")
    }
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from:", r)
        }
    }()
    panic("something went wrong")
}

Database connection failed: host=localhost, port=5432, user=admin

An error occurred. Please try again later.

An error occurred. Please contact support.

Error: SQL syntax error near "SELECT * FROM users WHERE id = 'abc'"

[ErrorCode: 1001] Unexpected error occurred. Contact support with this code.

import (
    "errors"
    "fmt"
)

func standardErrorExample() error {
    return errors.New("standard error occurred")
}

func main() {
    err := standardErrorExample()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

import "fmt"

// カスタムエラー型の定義
type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("Validation error on field '%s': %s", e.Field, e.Msg)
}

func customErrorExample() error {
    return &ValidationError{
        Field: "username",
        Msg:   "cannot be empty",
    }
}

func main() {
    err := customErrorExample()
    if err != nil {
        if vErr, ok := err.(*ValidationError); ok {
            fmt.Println("Custom Error:", vErr)
        } else {
            fmt.Println("Error:", err)
        }
    }
}

func validateInput(input string) error {
    if input == "" {
        return &ValidationError{Field: "input", Msg: "cannot be empty"}
    }
    return nil
}

import (
    "log"
    "os"
)

func main() {
    // ログファイルの設定
    file, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        log.Fatalf("failed to open log file: %s", err)
    }
    defer file.Close()
    log.SetOutput(file)

    // エラーをログに記録
    err = process()
    if err != nil {
        log.Printf("Error occurred: %s", err)
    }
}

func process() error {
    return fmt.Errorf("example error")
}

An unexpected error occurred. Please contact support with error code: 5001.

import (
    "fmt"
    "log"
)

func process() error {
    return fmt.Errorf("database connection failed: host=localhost, port=5432")
}

func main() {
    err := process()
    if err != nil {
        // ログに詳細を記録
        log.Printf("Detailed error: %s", err)

        // ユーザー向けメッセージを出力
        fmt.Println("An error occurred. Please try again later.")
    }
}

package main

import (
    "fmt"
    "log"
    "os"
)

// カスタムエラー型
type DatabaseError struct {
    Details string
}

func (e *DatabaseError) Error() string {
    return "database operation failed"
}

// データベース処理をシミュレーション
func connectToDatabase() error {
    // エラー発生
    return &DatabaseError{Details: "unable to connect to localhost:5432"}
}

func main() {
    // ログ設定
    file, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        log.Fatalf("failed to open log file: %s", err)
    }
    defer file.Close()
    log.SetOutput(file)

    // データベース接続
    err = connectToDatabase()
    if err != nil {
        // ログにエラーの詳細を記録
        log.Printf("Error details: %s", err)

        // ユーザーに抽象化されたエラーメッセージを表示
        fmt.Println("An error occurred. Please contact support.")
    }
}

package main

import (
    "fmt"
    "log"
)

type ValidationError struct {
    Code int
    Msg  string
}

func (e *ValidationError) Error() string {
    return e.Msg
}

func validateInput(input string) error {
    if input == "" {
        return &ValidationError{Code: 1001, Msg: "input cannot be empty"}
    }
    return nil
}

func main() {
    input := ""
    err := validateInput(input)
    if err != nil {
        if vErr, ok := err.(*ValidationError); ok {
            // ログにエラーコードと詳細を記録
            log.Printf("Validation Error [Code: %d]: %s", vErr.Code, vErr.Msg)

            // ユーザーにエラーコードを提示
            fmt.Printf("Error occurred. Code: %d\n", vErr.Code)
        } else {
            // 不明なエラーの場合
            log.Printf("Unexpected Error: %s", err)
            fmt.Println("An unexpected error occurred.")
        }
    }
}

import "log"

func init() {
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

// カスタムHTTPエラーハンドラー
func customErrorHandler(w http.ResponseWriter, r *http.Request) {
    // エラー詳細のログ出力
    log.Printf("Page not found: %s", r.URL.Path)

    // ユーザー向けエラーメッセージ
    http.Error(w, "The requested page could not be found.", http.StatusNotFound)
}

func main() {
    // ログファイル設定
    file, err := os.OpenFile("webapp.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        log.Fatalf("failed to open log file: %s", err)
    }
    defer file.Close()
    log.SetOutput(file)

    // ルート設定
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Welcome to the homepage!")
    })

    // カスタムエラーハンドラー設定
    http.HandleFunc("/error", customErrorHandler)

    // サーバー起動
    log.Println("Starting server on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "log"
    "net/http"
)

// ミドルウェアでエラーハンドリング
func errorMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Recovered from panic: %v", err)
                http.Error(w, "An internal error occurred. Please try again later.", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()

    // 通常のハンドラー
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Welcome to the site"))
    })

    // パニックを起こすハンドラー
    mux.HandleFunc("/panic", func(w http.ResponseWriter, r *http.Request) {
        panic("something went terribly wrong")
    })

    // ミドルウェアをラップ
    server := &http.Server{
        Addr:    ":8080",
        Handler: errorMiddleware(mux),
    }

    log.Println("Server running on :8080")
    log.Fatal(server.ListenAndServe())
}