Go言語のリフレクションで実現するロギングとトレースの自動生成

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name  string
    Email string
}

func main() {
    u := User{"Alice", "alice@example.com"}
    t := reflect.TypeOf(u)
    v := reflect.ValueOf(u)

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        fmt.Printf("Field: %s, Type: %s, Value: %v\n", field.Name, field.Type, value)
    }
}

package main

import (
    "log"
    "net/http"
    _ "net/http/pprof" // トレース用のプロファイラ
)

func main() {
    log.Println("Application started")

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Println("Received request")
        w.Write([]byte("Hello, World!"))
    })

    log.Println("Listening on :8080")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "reflect"
)

func LogFunctionCall(fn interface{}, args ...interface{}) {
    // リフレクションで関数情報を取得
    fnValue := reflect.ValueOf(fn)
    fnType := reflect.TypeOf(fn)

    // 関数名をログ出力
    fmt.Printf("Calling function: %s\n", runtime.FuncForPC(fnValue.Pointer()).Name())

    // 引数をログ出力
    for i, arg := range args {
        fmt.Printf("Arg %d: %v (Type: %s)\n", i, arg, fnType.In(i))
    }

    // 関数を呼び出し結果を取得
    inValues := make([]reflect.Value, len(args))
    for i, arg := range args {
        inValues[i] = reflect.ValueOf(arg)
    }
    results := fnValue.Call(inValues)

    // 戻り値をログ出力
    for i, result := range results {
        fmt.Printf("Result %d: %v\n", i, result.Interface())
    }
}

func Add(a int, b int) int {
    return a + b
}

func main() {
    // Add関数の呼び出しをログ付きで実行
    LogFunctionCall(Add, 3, 5)
}

package main

import (
    "fmt"
    "reflect"
    "runtime"
)

func LogWrapper(fn interface{}) interface{} {
    return func(args ...interface{}) []interface{} {
        // 関数情報を取得
        fnValue := reflect.ValueOf(fn)
        fnType := reflect.TypeOf(fn)

        // 関数名をログに出力
        funcName := runtime.FuncForPC(fnValue.Pointer()).Name()
        fmt.Printf("Calling function: %s\n", funcName)

        // 引数をログに出力
        inValues := make([]reflect.Value, len(args))
        for i, arg := range args {
            fmt.Printf("Arg %d: %v (Type: %s)\n", i, arg, fnType.In(i))
            inValues[i] = reflect.ValueOf(arg)
        }

        // 関数呼び出し
        outValues := fnValue.Call(inValues)

        // 戻り値をログに出力
        results := make([]interface{}, len(outValues))
        for i, result := range outValues {
            results[i] = result.Interface()
            fmt.Printf("Result %d: %v\n", i, results[i])
        }

        return results
    }
}

// サンプル関数
func Add(a, b int) int {
    return a + b
}

func main() {
    // Add関数をログラップして実行
    addWithLogging := LogWrapper(Add).(func(int, int) int)
    result := addWithLogging(3, 5)
    fmt.Printf("Final result: %d\n", result)
}

Calling function: main.Add
Arg 0: 3 (Type: int)
Arg 1: 5 (Type: int)
Result 0: 8
Final result: 8

package main

import (
    "fmt"
    "net/http"
    "reflect"
    "runtime"
    "time"
)

// トレース情報生成用ラッパー
func TraceWrapper(fn interface{}) interface{} {
    return func(args ...interface{}) []interface{} {
        // 関数情報を取得
        fnValue := reflect.ValueOf(fn)
        funcName := runtime.FuncForPC(fnValue.Pointer()).Name()

        // トレース開始
        start := time.Now()
        fmt.Printf("Tracing start: %s\n", funcName)

        // 引数情報
        inValues := make([]reflect.Value, len(args))
        for i, arg := range args {
            inValues[i] = reflect.ValueOf(arg)
            fmt.Printf("Arg %d: %v\n", i, arg)
        }

        // 関数実行
        results := fnValue.Call(inValues)

        // 実行結果と時間計測
        elapsed := time.Since(start)
        fmt.Printf("Tracing end: %s, Duration: %s\n", funcName, elapsed)

        returnValues := make([]interface{}, len(results))
        for i, result := range results {
            returnValues[i] = result.Interface()
            fmt.Printf("Result %d: %v\n", i, returnValues[i])
        }

        return returnValues
    }
}

// サンプルWeb APIハンドラー
func SampleHandler(w http.ResponseWriter, r *http.Request) {
    time.Sleep(100 * time.Millisecond) // 処理の遅延をシミュレーション
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    // ハンドラーにトレース機能をラップ
    tracedHandler := TraceWrapper(SampleHandler).(func(http.ResponseWriter, *http.Request))

    // HTTPサーバー起動
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        tracedHandler(w, r)
    })
    fmt.Println("Server started on :8080")
    http.ListenAndServe(":8080", nil)
}

Tracing start: main.SampleHandler
Arg 0: ResponseWriter
Arg 1: &{GET / HTTP/1.1 1 1 map[] ...}
Tracing end: main.SampleHandler, Duration: 100.123ms
Result 0: <nil>

package main

import (
    "fmt"
    "reflect"
)

var typeCache = map[string]reflect.Type{}

func getTypeName(obj interface{}) string {
    objType := reflect.TypeOf(obj)
    if cached, found := typeCache[objType.Name()]; found {
        return cached.Name()
    }
    typeCache[objType.Name()] = objType
    return objType.Name()
}

func main() {
    fmt.Println(getTypeName(42)) // 初回キャッシュ
    fmt.Println(getTypeName(42)) // キャッシュ再利用
}

package main

import (
    "net/http"
    _ "net/http/pprof" // pprof用
)

func main() {
    go func() {
        // プロファイルデータを提供するサーバー
        http.ListenAndServe("localhost:6060", nil)
    }()
}

package main

import (
    "github.com/sirupsen/logrus"
)

func main() {
    log := logrus.New()
    log.SetFormatter(&logrus.JSONFormatter{}) // JSON形式での出力

    // リフレクションを使ってフィールドを動的に追加
    log.WithField("function", "main").Info("Application started")
}

package main

import (
    "go.uber.org/zap"
)

func main() {
    logger, _ := zap.NewProduction()
    defer logger.Sync()

    // 動的にフィールドを追加したログ出力
    logger.Info("Starting application",
        zap.String("module", "main"),
        zap.Int("version", 1),
    )
}

package main

import (
    "fmt"

    "github.com/jmoiron/sqlx/reflectx"
)

type User struct {
    Name  string `db:"name"`
    Email string `db:"email"`
}

func main() {
    m := reflectx.NewMapper("db")

    user := User{"Alice", "alice@example.com"}
    fields := m.TypeMap(reflectx.Deref(reflect.TypeOf(user)))

    for name, field := range fields.Names {
        fmt.Printf("Field: %s, Tag: %s\n", name, field.Tag.Get("db"))
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/sirupsen/logrus"
)

// ロギング用ミドルウェア
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // リクエスト情報をログ
        log := logrus.New()
        log.SetFormatter(&logrus.JSONFormatter{})

        // リクエストヘッダーとメソッド、パス
        log.WithFields(logrus.Fields{
            "method": r.Method,
            "path":   r.URL.Path,
            "header": r.Header,
        }).Info("Request received")

        // レスポンスのラップ
        lrw := &loggingResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        next.ServeHTTP(lrw, r)

        // レスポンス情報をログ
        log.WithFields(logrus.Fields{
            "status":       lrw.statusCode,
            "responseTime": time.Since(start),
        }).Info("Request completed")
    })
}

// レスポンス情報を記録するラッパー
type loggingResponseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (lrw *loggingResponseWriter) WriteHeader(code int) {
    lrw.statusCode = code
    lrw.ResponseWriter.WriteHeader(code)
}

// サンプルハンドラー
func HelloHandler(w http.ResponseWriter, r *http.Request) {
    response := map[string]string{"message": "Hello, World!"}
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(response)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", HelloHandler)

    // ロギングミドルウェアを適用
    loggedMux := LoggingMiddleware(mux)

    fmt.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", loggedMux))
}

{
  "level": "info",
  "method": "GET",
  "path": "/",
  "header": {
    "User-Agent": ["curl/7.68.0"],
    "Accept": ["*/*"]
  },
  "msg": "Request received",
  "time": "2024-11-20T12:34:56Z"
}
{
  "level": "info",
  "status": 200,
  "responseTime": "1.23ms",
  "msg": "Request completed",
  "time": "2024-11-20T12:34:56Z"
}