从os.stdin读取日志的Golang实现方法

您的代码中存在几个问题，主要是在服务器程序中错误地使用了标准输入。服务器程序应该从syslog通道接收数据，而不是向标准输入写入数据。

服务器代码修正：

package main

import (
    "fmt"
    "gopkg.in/mcuadros/go-syslog.v2"
)

func main() {
    channel := make(syslog.LogPartsChannel)
    handler := syslog.NewChannelHandler(channel)
    server := syslog.NewServer()
    server.SetFormat(syslog.RFC3164)
    server.SetHandler(handler)
    
    fmt.Println("Nginx syslog server starting...")
    server.ListenUDP("0.0.0.0:1515")
    server.Boot()
    
    go func(channel syslog.LogPartsChannel) {
        for logParts := range channel {
            // 直接处理日志内容，而不是写入stdin
            if content, ok := logParts["content"]; ok {
                fmt.Printf("Received log: %v\n", content)
            }
        }
    }(channel)
    
    server.Wait()
}

消费者代码修正：

您的消费者代码基本正确，但如果要从标准输入持续读取流式数据，需要调整读取逻辑：

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
    "strings"
    "github.com/satyrius/gonx"
)

var conf string
var format string
var logFile string

func init() {
    flag.StringVar(&conf, "conf", "dummy", "Nginx config file (e.g. /etc/nginx/nginx.conf)")
    flag.StringVar(&format, "format", "main", "Nginx log_format name")
    flag.StringVar(&logFile, "log", "-", "Log file name to read. Read from STDIN if file name is '-'")
}

func main() {
    flag.Parse()
    
    // 配置nginx日志格式
    var nginxConfig io.Reader
    if conf == "dummy" {
        nginxConfig = strings.NewReader(`http { log_format main '$remote_addr [$time_local] "$request"'; }`)
    } else {
        nginxConfigFile, err := os.Open(conf)
        if err != nil {
            panic(err)
        }
        nginxConfig = nginxConfigFile
        defer nginxConfigFile.Close()
    }
    
    // 从标准输入持续读取
    if logFile == "-" {
        scanner := bufio.NewScanner(os.Stdin)
        reader, err := gonx.NewNginxReader(strings.NewReader(""), nginxConfig, format)
        if err != nil {
            panic(err)
        }
        
        for scanner.Scan() {
            line := scanner.Text()
            lineReader := strings.NewReader(line)
            reader, err := gonx.NewNginxReader(lineReader, nginxConfig, format)
            if err != nil {
                fmt.Printf("Error creating reader: %v\n", err)
                continue
            }
            
            rec, err := reader.Read()
            if err != nil && err != io.EOF {
                fmt.Printf("Error parsing log: %v\n", err)
                continue
            }
            
            fmt.Printf("Parsed entry: %+v\n", rec)
        }
        
        if err := scanner.Err(); err != nil {
            fmt.Printf("Error reading stdin: %v\n", err)
        }
    } else {
        // 文件读取逻辑保持不变
        var logReader io.Reader
        if logFile == "dummy" {
            logReader = strings.NewReader(`89.234.89.123 [08/Nov/2013:13:39:18 +0000] "GET /api/foo/bar HTTP/1.1"`)
        } else {
            file, err := os.Open(logFile)
            if err != nil {
                panic(err)
            }
            logReader = file
            defer file.Close()
        }
        
        reader, err := gonx.NewNginxReader(logReader, nginxConfig, format)
        if err != nil {
            panic(err)
        }
        
        for {
            rec, err := reader.Read()
            if err == io.EOF {
                break
            } else if err != nil {
                panic(err)
            }
            fmt.Printf("Parsed entry: %+v\n", rec)
        }
    }
}

关键修改点：

1. 服务器程序移除了向os.Stdin写入的错误逻辑，改为直接处理接收到的日志内容
2. 消费者程序使用bufio.Scanner来持续从标准输入读取流式数据
3. 为每一行日志创建新的reader进行解析，避免EOF问题

这样的架构允许服务器接收syslog消息，而消费者可以从标准输入管道接收并解析日志数据。