1 package main
 2
 3 import (
 4     "fmt"
 5     "time"
 6     "github.com/Shopify/sarama"
 7 )
 8
 9 func main() {
10
11     config := sarama.NewConfig()
12     config.Producer.RequiredAcks = sarama.WaitForAll
13     config.Producer.Partitioner = sarama.NewRandomPartitioner
14     config.Producer.Return.Successes = true
15
16     client, err := sarama.NewSyncProducer([]string{"192.168.30.136:9092"}, config)
17     if err != nil {
18         fmt.Println("producer close, err:", err)
19         return
20     }
21
22     defer client.Close()
23     for {
24         msg := &sarama.ProducerMessage{}
25         msg.Topic = "nginx_log"
26         msg.Value = sarama.StringEncoder("this is a good test, my message is good")
27
28         pid, offset, err := client.SendMessage(msg)
29         if err != nil {
30             fmt.Println("send message failed,", err)
31             return
32         }
33
34         fmt.Printf("pid:%v offset:%v\n", pid, offset)
35         time.Sleep(time.Second)
36     }
37 }

 1 package main
 2
 3 import (
 4     "fmt"
 5     "github.com/Shopify/sarama"
 6 )
 7
 8 func main() {
 9     // 新建一个arama配置实例
10     config := sarama.NewConfig()
11     // WaitForAll waits for all in-sync replicas to commit before responding.
12     config.Producer.RequiredAcks = sarama.WaitForAll
13     // NewRandomPartitioner returns a Partitioner which chooses a random partition each time.
14     config.Producer.Partitioner = sarama.NewRandomPartitioner
15     config.Producer.Return.Successes = true
16
17     // new producer
18     client, err := sarama.NewSyncProducer([]string{"192.168.30.136:9092"}, config)
19     if err != nil {
20         fmt.Println("producer close, err:", err)
21         return
22     }
23     defer client.Close()
24
25     // new message
26     msg := &sarama.ProducerMessage{}
27     msg.Topic = "food"
28     msg.Key = sarama.StringEncoder("fruit")
29     msg.Value = sarama.StringEncoder("apple")
30
31     // send message
32     pid, offset, err := client.SendMessage(msg)
33     if err != nil {
34         fmt.Println("send message failed,", err)
35         return
36     }
37     fmt.Printf("pid: %v, offset:%v\n", pid, offset)
38
39     // new message
40     msg2 := &sarama.ProducerMessage{}
41     msg2.Topic = "food"
42     msg2.Key = sarama.StringEncoder("fruit")
43     msg2.Value = sarama.StringEncoder("orange")
44
45     // send message
46     pid2, offset2, err := client.SendMessage(msg2)
47     if err != nil {
48         fmt.Println("send message failed,", err)
49         return
50     }
51     fmt.Printf("pid2: %v, offset2:%v\n", pid2, offset2)
52
53     fmt.Println("Produce success.")
54 }

 1 package main
 2
 3 import (
 4     "sync"
 5     "github.com/Shopify/sarama"
 6     "fmt"
 7 )
 8
 9 var wg sync.WaitGroup
10
11 func main() {
12     consumer, err := sarama.NewConsumer([]string{"192.168.30.136:9092"}, nil)
13     if err != nil {
14         fmt.Println("consumer connect error:", err)
15         return
16     }
17     fmt.Println("connnect success...")
18     defer consumer.Close()
19
20     partitions, err := consumer.Partitions("food")
21     if err != nil {
22         fmt.Println("geet partitions failed, err:", err)
23         return
24     }
25
26     for _, p := range partitions {
27         partitionConsumer, err := consumer.ConsumePartition("food", p, sarama.OffsetOldest)
28         if err != nil {
29             fmt.Println("partitionConsumer err:", err)
30             continue
31         }
32         wg.Add(1)
33         go func(){
34             for m := range partitionConsumer.Messages() {
35                 fmt.Printf("key: %s, text: %s, offset: %d\n", string(m.Key), string(m.Value), m.Offset)
36             }
37             wg.Done()
38         }()
39     }
40     wg.Wait()
41
42     fmt.Println("Consumer success.")
43 }

 1 package main
 2
 3 import (
 4     "fmt"
 5     "github.com/hpcloud/tail"
 6     "time"
 7 )
 8 func main() {
 9     filename := "F:\\Go\\project\\src\\go_dev\\logCollect\\tailf\\my.log"
10     tails, err := tail.TailFile(filename, tail.Config{
11         ReOpen:    true,
12         Follow:    true,
13         //Location:  &tail.SeekInfo{Offset: 0, Whence: 2},
14         MustExist: false,
15         Poll:      true,
16     })
17     if err != nil {
18         fmt.Println("tail file err:", err)
19         return
20     }
21     var msg *tail.Line
22     var ok bool
23     for {
24         msg, ok = <-tails.Lines
25         if !ok {
26             fmt.Printf("tail file close reopen, filename:%s\n", tails.Filename)
27             time.Sleep(100 * time.Millisecond)
28             continue
29         }
30         fmt.Println("msg:", msg)
31     }
32 }

 1 package main
 2
 3 import (
 4     "fmt"
 5     "github.com/astaxie/beego/config"
 6 )
 7
 8 func main() {
 9     conf, err := config.NewConfig("ini", "./logcollect.conf")
10     if err != nil {
11         fmt.Println("new config failed, err:", err)
12         return
13     }
14
15     port, err := conf.Int("server::listen_port")
16     if err != nil {
17         fmt.Println("read server:port failed, err:", err)
18         return
19     }
20
21     fmt.Println("Port:", port)
22     log_level := conf.String("log::log_level")
23     if err != nil {
24         fmt.Println("read log_level failed, ", err)
25         return
26     }
27     fmt.Println("log_level:", log_level)
28
29     log_path := conf.String("log::log_path")
30     fmt.Println("log_path:", log_path)
31 }

 1 package main
 2
 3 import (
 4     "encoding/json"
 5     "fmt"
 6     "github.com/astaxie/beego/logs"
 7 )
 8
 9 func main() {
10     config := make(map[string]interface{})
11     config["filename"] = "./logcollect.log"
12     config["level"] = logs.LevelDebug
13
14     configStr, err := json.Marshal(config)
15     if err != nil {
16         fmt.Println("marshal failed, err:", err)
17         return
18     }
19
20     logs.SetLogger(logs.AdapterFile, string(configStr))
21
22     logs.Debug("this is a test, my name is %s", "stu01")
23     logs.Trace("this is a trace, my name is %s", "stu02")
24     logs.Warn("this is a warn, my name is %s", "stu03")
25 }