GoLang log monitoring system implementation

package main
import (
	"fmt"
	"strings"
	"time"
)
/**
 * The log analysis system is divided into: parsing, reading, and writing
  */
type LogProcess struct {
	path        string      // Read file path	influxDBDsn string      // influx data source
	rc          chan string // read module to process
	wc          chan string // process to influx
}
// Return function uses pointers, the structure is large and does not require copying. Performance optimizationfunc (l *LogProcess) ReadFromFile() {
	// File reading module	line := "message"
	 <- line
}
func (l *LogProcess) Process() {
	// File parsing module	data := <-
	 <- (data)
}
func (l *LogProcess) writeToInfluxDB() {
	(<-)
}
func main() {
	// lp reference type	lp := &LogProcess{
		path:        "./tmp/",
		influxDBDsn: "username&password...",
		rc:          make(chan string),
		wc:          make(chan string),
	}
	// tree goroutine run
	go ()
	go ()
	// chan needs to be defined to pass Process data to influxDB	go ()
	(2 * )
}

package main
import (
	"fmt"
	"strings"
	"time"
)
/**
 * The log analysis system is divided into: parsing, reading, and writing
  */
type LogProcess struct {
	rc    chan string // read module to process
	wc    chan string // process to influx
	read  Read
	write Writer
}
func (l *LogProcess) Process() {
	// File parsing module	data := <-
	 <- (data)
}
type Writer interface {
	writer(wc chan string)
}
type WriteToInfluxDB struct {
	influxDBDsn string // influx data source
}
func (w *WriteToInfluxDB) writer(wc chan string) {
	(<-wc)
}
type Read interface {
	read(rc chan string)
}
type ReadFromFile struct {
	path string // Read the file}
func (r *ReadFromFile) read(rc chan string) {
	// Read module	line := "message"
	rc <- line
}
func main() {
	// lp reference type	r := &ReadFromFile{
		path: "./tmp/",
	}
	w := &WriteToInfluxDB{
		influxDBDsn: "username&password"}
	lp := &LogProcess{
		rc:    make(chan string),
		wc:    make(chan string),
		read:  r,
		write: w,
	}
	// Constrain its functions through interface	go ()
	go ()
	go ()
	// Through parameter injection	(2 * )
}

package main
import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strings"
	"time"
)
/**
 * The log analysis system is divided into: parsing, reading, and writing
  */
type LogProcess struct {
	rc    chan []byte // read module to process
	wc    chan string // process to influx
	read  Read
	write Writer
}
func (l *LogProcess) Process() {
	// File parsing module	for v := range  {
		 <- (string(v))
	}
}
type Writer interface {
	writer(wc chan string)
}
type WriteToInfluxDB struct {
	influxDBDsn string // influx data source
}
func (w *WriteToInfluxDB) writer(wc chan string) {
	// Another way to read the wc channel	for x := range wc {
		(x)
	}
}
type Read interface {
	read(rc chan []byte)
}
type ReadFromFile struct {
	path string // Read the file}
func (r *ReadFromFile) read(rc chan []byte) {
	// Real-time system: Read line by line from the end of the file	f, err := ()
	if err != nil {
		panic(("open file error:%s", ()))
	}
	// Read at the end of the file at the beginning	(0, 2)
	rd := (f)
	for {
		line, err := ('\n')
		if err ==  {
			// d read to the end of the file, the log has not been written yet			(500 * )
			continue
		} else if err != nil {
			panic(("ReadBytes error:%s", ()))
		}
		rc <- line[:len(line)-1]
	}
}
func main() {
	// lp reference type	r := &ReadFromFile{
		path: "H:\\code\\goprogarm\\src\\",
	}
	w := &WriteToInfluxDB{
		influxDBDsn: "username&password"}
	lp := &LogProcess{
		rc:    make(chan []byte),
		wc:    make(chan string),
		read:  r,
		write: w,
	}
	// Constrain its functions through interface	go ()
	go ()
	go ()
	// Through parameter injection	(100 * )
}

package main
import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
	"regexp"
	"strconv"
	"time"
)
/**
 * The log analysis system is divided into: parsing, reading, and writing
  */
type LogProcess struct {
	rc    chan []byte // read module to process
	wc    chan *Message // process to influx
	read  Read
	write Writer
}
//Login writing to structuretype Message struct {
	TimeLocal 
	BytesSent int
	Path, Method, Scheme, Status string
	UpstreamTime, RequestTime float64
}
func (l *LogProcess) Process() {
	// parse data through regular expressions	r := (`(\s*)`)
	loc, _ := ("Asia/shanghai")
	// File parsing module	for v := range  {
		ret := (string(v))
		if len(ret) != 13 {
			("FindStringSub match fail:", string(v))
			continue
		}
		message := &Message{
		}
		location, err := ("02/Jan/2006:15:04:05 +0000", ret[4], loc)
		if err != nil {
			("ParseInLocation fail:", (), ret[4])
		}
		 = location
		// Convert string type to int		atoi, err := (ret[8])
		if err != nil {
			(" fail:", (), ret[4])
		}
		 = atoi
		 <- message
	}
}
type Writer interface {
	writer(wc chan *Message)
}
type WriteToInfluxDB struct {
	influxDBDsn string // influx data source
}
func (w *WriteToInfluxDB) writer(wc chan *Message) {
	// Another way to read the wc channel	for x := range wc {
		(x)
	}
}
type Read interface {
	read(rc chan []byte)
}
type ReadFromFile struct {
	path string // Read the file}
func (r *ReadFromFile) read(rc chan []byte) {
	// Real-time system: Read line by line from the end of the file	f, err := ()
	if err != nil {
		panic(("open file error:%s\n", ()))
	}
	// Read at the end of the file at the beginning	(0, 2)
	rd := (f)
	for {
		line, err := ('\n')
		if err ==  {
			// d read to the end of the file, the log has not been written yet			(500 * )
			continue
		} else if err != nil {
			panic(("ReadBytes error:%s\n", ()))
		}
		rc <- line[:len(line)-1]
	}
}
func main() {
	// lp reference type	r := &ReadFromFile{
		path: "H:\\code\\goprogarm\\src\\",
	}
	w := &WriteToInfluxDB{
		influxDBDsn: "username&password"}
	lp := &LogProcess{
		rc:    make(chan []byte),
		wc:    make(chan *Message),
		read:  r,
		write: w,
	}
	// Constrain its functions through interface	go ()
	go ()
	go ()
	// Through parameter injection	(100 * )
}