func (k *Kafka) Write(points []*client.Point) error { if len(points) == 0 { return nil } for _, p := range points { // Combine tags from Point and BatchPoints and grab the resulting // line-protocol output string to write to Kafka value := p.String() m := &sarama.ProducerMessage{ Topic: k.Topic, Value: sarama.StringEncoder(value), } if h, ok := p.Tags()[k.RoutingTag]; ok { m.Key = sarama.StringEncoder(h) } _, _, err := k.producer.SendMessage(m) if err != nil { return errors.New(fmt.Sprintf("FAILED to send kafka message: %s\n", err)) } } return nil }
func forwarding(pl ...ProcessLogic) ProcessLogic { return eventProcessor(func(n fsmonitor.Notice) { for _, p := range pl { p.Process(n) } /* If no message key set, all messages will be distributed randomly * over the different partitions.*/ partition, offset, err := noticeSender.SendMessage(&sarama.ProducerMessage{ Topic: *topic, Key: sarama.StringEncoder(fmt.Sprintf("%v", n.Type())), Value: sarama.StringEncoder(n.Name()), }) if err != nil { Logger.Printf("Failed to store your data:, %s", err) } else { // The tuple (topic, partition, offset) can be used as a unique identifier // for a message in a Kafka cluster. Logger.Printf("Your data is stored with unique identifier kafka://%s/%d/%d", *topic, partition, offset) } }) }
func (q KafkaTopic) Enqueue(key, value string) { q.Producable <- &sarama.ProducerMessage{ Topic: q.Topic, Key: sarama.StringEncoder(key), Value: sarama.StringEncoder(value), } }
func (k *Kafka) Write(metrics []telegraf.Metric) error { if len(metrics) == 0 { return nil } for _, metric := range metrics { values, err := k.serializer.Serialize(metric) if err != nil { return err } var pubErr error for _, value := range values { m := &sarama.ProducerMessage{ Topic: k.Topic, Value: sarama.StringEncoder(value), } if h, ok := metric.Tags()[k.RoutingTag]; ok { m.Key = sarama.StringEncoder(h) } _, _, pubErr = k.producer.SendMessage(m) } if pubErr != nil { return fmt.Errorf("FAILED to send kafka message: %s\n", pubErr) } } return nil }
func Publish(input chan *FileEvent, source string, ctrl chan bool) { clientConfig := sarama.NewConfig() clientConfig.Producer.RequiredAcks = sarama.WaitForLocal clientConfig.Producer.Compression = sarama.CompressionSnappy clientConfig.Producer.Flush.Frequency = 500 * time.Millisecond clientConfig.Producer.Flush.Messages = 200 clientConfig.Producer.Flush.MaxMessages = 200 clientConfig.Producer.Flush.Bytes = 16384 clientConfig.Producer.Return.Successes = true clientConfig.Producer.Partitioner = sarama.NewRoundRobinPartitioner clientConfig.ChannelBufferSize = kafkabuffer //brokerList := []string{"127.0.0.1:9092"} var producer sarama.AsyncProducer var err error for { producer, err = sarama.NewAsyncProducer(brokerList, clientConfig) if err != nil { log.Error("Publish: Failed to start Sarama producer: ", err) log.Info("waiting....") time.Sleep(1 * time.Second) } else { break } } defer func() { if err := producer.Close(); err != nil { log.Error("Failed to shutdown producer cleanly", err) } }() registrar := &Registrar{source: source, publishCtrl: ctrl} go registrar.RegistrarDo(producer.Errors(), producer.Successes()) topic := kafkaTopic baseName := filepath.Base(source) if len(topicmap) > 0 { tmpTopic := genTopic(baseName, topicmap) if tmpTopic != "" { topic = tmpTopic } } key := hashKey for event := range input { log.Debugf("%v, %v, %v, %v", *event.Source, *event.Text, event.Line, event.Offset) key = strconv.FormatInt(event.Offset, 10) producer.Input() <- &sarama.ProducerMessage{ Topic: topic, Key: sarama.StringEncoder(key), Value: sarama.StringEncoder(*event.Text), Metadata: event, } } }
func main() { // Setup configuration config := sarama.NewConfig() // Return specifies what channels will be populated. // If they are set to true, you must read from // config.Producer.Return.Successes = true // The total number of times to retry sending a message (default 3). config.Producer.Retry.Max = 5 // The level of acknowledgement reliability needed from the broker. config.Producer.RequiredAcks = sarama.WaitForAll brokers := []string{"localhost:9092"} producer, err := sarama.NewAsyncProducer(brokers, config) if err != nil { // Should not reach here panic(err) } defer func() { if err := producer.Close(); err != nil { // Should not reach here panic(err) } }() signals := make(chan os.Signal, 1) signal.Notify(signals, os.Interrupt) var enqueued, errors int doneCh := make(chan struct{}) go func() { for { time.Sleep(500 * time.Millisecond) strTime := strconv.Itoa(int(time.Now().Unix())) msg := &sarama.ProducerMessage{ Topic: "important", Key: sarama.StringEncoder(strTime), Value: sarama.StringEncoder("Something Cool"), } select { case producer.Input() <- msg: enqueued++ fmt.Println("Produce message") case err := <-producer.Errors(): errors++ fmt.Println("Failed to produce message:", err) case <-signals: doneCh <- struct{}{} } } }() <-doneCh log.Printf("Enqueued: %d; errors: %d\n", enqueued, errors) }
func (suite *KafkaTester) Test01() { t := suite.T() assert := assert.New(t) const M1 = "message one" const M2 = "message two" var producer sarama.AsyncProducer var consumer sarama.Consumer var partitionConsumer sarama.PartitionConsumer var err error topic := makeTopicName() { config := sarama.NewConfig() config.Producer.Return.Successes = false config.Producer.Return.Errors = false producer, err = sarama.NewAsyncProducer([]string{suite.server}, config) assert.NoError(err) defer close(t, producer) producer.Input() <- &sarama.ProducerMessage{ Topic: topic, Key: nil, Value: sarama.StringEncoder(M1)} producer.Input() <- &sarama.ProducerMessage{ Topic: topic, Key: nil, Value: sarama.StringEncoder(M2)} } { consumer, err = sarama.NewConsumer([]string{suite.server}, nil) assert.NoError(err) defer close(t, consumer) partitionConsumer, err = consumer.ConsumePartition(topic, 0, 0) assert.NoError(err) defer close(t, partitionConsumer) } { mssg1 := <-partitionConsumer.Messages() //t.Logf("Consumed: offset:%d value:%v", mssg1.Offset, string(mssg1.Value)) mssg2 := <-partitionConsumer.Messages() //t.Logf("Consumed: offset:%d value:%v", mssg2.Offset, string(mssg2.Value)) assert.EqualValues(M1, string(mssg1.Value)) assert.EqualValues(M2, string(mssg2.Value)) } }
func main() { config := sarama.NewConfig() config.Producer.RequiredAcks = sarama.WaitForAll brokers := []string{"localhost:9092"} producer, err := sarama.NewAsyncProducer(brokers, config) if err != nil { panic(err) } defer func() { if err := producer.Close(); err != nil { panic(err) } }() deviceIds := [1]string{"28-00000626aa4d"} for i := 0; i < len(deviceIds); i++ { deviceId := deviceIds[i] go func() { for { temperatureValue := getTemperatureValue(deviceId) fmt.Println(temperatureValue) msg := &sarama.ProducerMessage{ Topic: "important", Key: sarama.StringEncoder(deviceId), Value: sarama.StringEncoder(strconv.FormatFloat(temperatureValue, 'E', -1, 64)), } select { case producer.Input() <- msg: fmt.Println("Produce message") case err := <-producer.Errors(): fmt.Println("Failed to produce message:", err) } time.Sleep(5 * time.Second) } }() } select {} }
func main() { configFile := flag.String("c", "", "Config file") messageValue := flag.String("m", "", "Message") amount := flag.Int("a", 1, "Amount of messages") flag.Parse() if *configFile == "" || *messageValue == "" { flag.PrintDefaults() os.Exit(1) } options, err := revolver.LoadOptions(*configFile) if err != nil { log.Fatalln(err) os.Exit(1) } sarama.Logger = logger var keyEncoder, valueEncoder sarama.Encoder keyEncoder = sarama.StringEncoder(time.Now().String()) if *messageValue != "" { valueEncoder = sarama.StringEncoder(*messageValue) } config := sarama.NewConfig() config.Producer.Partitioner = sarama.NewRandomPartitioner producer, err := sarama.NewSyncProducer(options.Brokers, config) if err != nil { logger.Fatalln("FAILED to open the producer:", err) } defer producer.Close() topic := options.KafkaTopics[0] for i := 0; i < *amount; i++ { partition, offset, err := producer.SendMessage(&sarama.ProducerMessage{ Topic: topic, Key: keyEncoder, Value: valueEncoder, }) if err != nil { logger.Println("FAILED to produce message:", err) } else { logger.Printf("msg: %d, topic=%s\tpartition=%d\toffset=%d\n", i, topic, partition, offset) } } }
func pubKafkaLoop(seq int) { cf := sarama.NewConfig() cf.Producer.RequiredAcks = sarama.WaitForLocal cf.Producer.Partitioner = sarama.NewHashPartitioner cf.Producer.Timeout = time.Second //cf.Producer.Compression = sarama.CompressionSnappy cf.Producer.Retry.Max = 3 producer, err := sarama.NewSyncProducer([]string{"localhost:9092"}, cf) if err != nil { stress.IncCounter("fail", 1) log.Println(err) return } defer producer.Close() msg := strings.Repeat("X", sz) for i := 0; i < loops; i++ { _, _, err := producer.SendMessage(&sarama.ProducerMessage{ Topic: topic, Value: sarama.StringEncoder(msg), }) if err == nil { stress.IncCounter("ok", 1) } else { stress.IncCounter("fail", 1) } } }
func main() { flag.Parse() if *brokers == "" { flag.PrintDefaults() os.Exit(1) } brokerList := strings.Split(*brokers, ",") producer := newAsyncProducer(brokerList) f, err := os.Open(*filename) defer f.Close() if err != nil { log.Fatal("Could not open raw file:", err) } scanner := bufio.NewScanner(f) scanner.Split(bufio.ScanLines) for scanner.Scan() { producer.Input() <- &sarama.ProducerMessage{ Topic: *topic, Value: sarama.StringEncoder(scanner.Text()), } } }
func (tp *TypedProducer) produce(cmData *CmData) { // logger.Debug("produce requiredAcks=%d", int(tp.requiredAcks)) // fetch and fill pmpe := tp.pmp.fetch() pmpe.privData = cmData pmsg := pmpe.pmsg pmsg.Topic = cmData.topic if len(cmData.key) == 0 { // if key is empty, using sarama.RandomPartitioner pmsg.Key = nil } else { pmsg.Key = sarama.StringEncoder(cmData.key) } pmsg.Value = sarama.ByteEncoder(cmData.data) pmsg.Metadata = pmpe // do produce for { select { case tp.ap.Input() <-pmsg: return case perr := <-tp.ap.Errors(): tp.processProduceErrors(perr) } } }
func (o *KafkaOutput) Write(data []byte) (n int, err error) { headers := make(map[string]string) proto.ParseHeaders([][]byte{data}, func(header []byte, value []byte) bool { headers[string(header)] = string(value) return true }) req := payloadBody(data) kafkaMessage := KafkaMessage{ ReqURL: string(proto.Path(req)), ReqMethod: string(proto.Method(req)), ReqBody: string(proto.Body(req)), ReqHeaders: headers, } jsonMessage, _ := json.Marshal(&kafkaMessage) message := sarama.StringEncoder(jsonMessage) o.producer.Input() <- &sarama.ProducerMessage{ Topic: o.config.topic, Value: message, } return len(message), nil }
func broadcastKafka(msg []byte) (err error) { message := &sarama.ProducerMessage{Topic: KafkaPushsTopic, Key: sarama.StringEncoder(define.KAFKA_MESSAGE_BROADCAST), Value: sarama.ByteEncoder(msg)} if _, _, err = producer.SendMessage(message); err != nil { return } return }
func broadcastRoomKafka(ridStr string, msg []byte) (err error) { message := &sarama.ProducerMessage{Topic: KafkaPushsTopic, Key: sarama.StringEncoder(ridStr), Value: sarama.ByteEncoder(msg)} if _, _, err = producer.SendMessage(message); err != nil { return } return }
func work() error { config, err := initConfig() if err != nil { return err } client, producer, err := gomkafka.Gomkafka(config) if err != nil { panic(err) } defer client.Close() defer producer.Close() in := bufio.NewReader(os.Stdin) for { msg, err := in.ReadString('\n') if err != nil { return err } err = producer.SendMessage("monitoring", nil, kafka.StringEncoder(msg)) if err != nil { return err } time.Sleep(1 * time.Millisecond) } }
func main() { flag.Parse() if *brokers == "" { flag.PrintDefaults() os.Exit(1) } brokerList := strings.Split(*brokers, ",") producer := newSyncProducer(brokerList) resp, _ := http.Get("http://developer.usa.gov/1usagov") reader := bufio.NewReader(resp.Body) for { line, err := reader.ReadBytes('\n') if err != nil { log.Println("Failed to ReadBytes:", err) } if isJSON(line) { producer.SendMessage(&sarama.ProducerMessage{ Topic: *topic, Value: sarama.StringEncoder(line), }) } } }
func main() { flag.Parse() if *host == "" || *topic == "" || *logfile == "" { fmt.Printf("pararm error,host=%s,topic=%s,logfile=%s\n", *host, *topic, *logfile) os.Exit(0) } hosts := strings.Split(*host, ",") producer, err := sarama.NewSyncProducer(hosts, nil) if err != nil { fmt.Printf("create kafka syncproducer fail. %+v\n", err) os.Exit(-1) } defer producer.Close() file, err1 := os.Open(*logfile) if err1 != nil { fmt.Printf("open logfile %s fail. %+v\n", *logfile, err1) os.Exit(-2) } defer file.Close() scanner := bufio.NewScanner(file) for scanner.Scan() { msg := &sarama.ProducerMessage{Topic: *topic, Value: sarama.StringEncoder(scanner.Text())} _, _, err := producer.SendMessage(msg) if err != nil { fmt.Printf("FAILED to send message: %s\n", err) } } if err := scanner.Err(); err != nil { log.Fatal(err) } }
func (c *KafkaClient) PutTopicMsg(topic, text string) { msg := &sarama.ProducerMessage{Topic: topic, Value: sarama.StringEncoder(text)} _, _, err := c.Porducer.SendMessage(msg) if err != nil { log.Printf("FAILED to send message: %s\n", err) } }
func newProducerMessage(cp ChainPartition, payload []byte) *sarama.ProducerMessage { return &sarama.ProducerMessage{ Topic: cp.Topic(), Key: sarama.StringEncoder(strconv.Itoa(int(cp.Partition()))), // TODO Consider writing an IntEncoder? Value: sarama.ByteEncoder(payload), } }
func generateKafkaData(t *testing.T, topic string) { config := sarama.NewConfig() client, err := sarama.NewClient([]string{getTestKafkaHost()}, config) if err != nil { t.Errorf("%s", err) } producer, err := sarama.NewSyncProducerFromClient(client) if err != nil { t.Error(err) } defer producer.Close() msg := &sarama.ProducerMessage{ Topic: topic, Value: sarama.StringEncoder("Hello World"), } _, _, err = producer.SendMessage(msg) if err != nil { t.Errorf("FAILED to send message: %s\n", err) } client.RefreshMetadata(topic) }
func (s *Server) withAccessLog(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { started := time.Now() next.ServeHTTP(w, r) entry := &accessLogEntry{ Method: r.Method, Host: r.Host, Path: r.RequestURI, IP: r.RemoteAddr, ResponseTime: float64(time.Since(started)) / float64(time.Second), } // We will use the client's IP address as key. This will cause // all the access log entries of the same IP address to end up // on the same partition. s.AccessLogProducer.Input() <- &sarama.ProducerMessage{ Topic: "access_log", Key: sarama.StringEncoder(r.RemoteAddr), Value: entry, } }) }
func main() { config := sarama.NewConfig() config.Producer.RequiredAcks = sarama.WaitForAll config.Producer.Retry.Max = 5 // brokers := []string{"192.168.59.103:9092"} brokers := []string{"localhost:9092"} producer, err := sarama.NewSyncProducer(brokers, config) if err != nil { // Should not reach here panic(err) } defer func() { if err := producer.Close(); err != nil { // Should not reach here panic(err) } }() topic := "important" msg := &sarama.ProducerMessage{ Topic: topic, Value: sarama.StringEncoder("Something Cool"), } partition, offset, err := producer.SendMessage(msg) if err != nil { panic(err) } fmt.Printf("Message is stored in topic(%s)/partition(%d)/offset(%d)\n", topic, partition, offset) }
func (i *IndeedKafkaProducer) SendMessages(jobResultChannel <-chan mapping.JobResult) (<-chan error, <-chan int) { errorChannel := make(chan error) kafkaDoneChannel := make(chan int) go func() { defer close(errorChannel) defer close(kafkaDoneChannel) defer i.Close() for jobResult := range jobResultChannel { if jobResult.IsLast() { eatonevents.Debug("received last jobResult. returning from function and signaling that the job is complete.") kafkaDoneChannel <- 0 return } bytes, err := xml.Marshal(jobResult) if err != nil { errorChannel <- err continue } eatonevents.Debug(fmt.Sprintf("Sending JobResult JobKey: %s", jobResult.JobKey)) i.producer.Input() <- &sarama.ProducerMessage{ Topic: eatonconfig.KafkaTopic, Value: sarama.ByteEncoder(bytes), Key: sarama.StringEncoder(jobResult.JobKey), } } }() return errorChannel, kafkaDoneChannel }
func TestReadsMetricsFromKafka(t *testing.T) { if testing.Short() { t.Skip("Skipping integration test in short mode") } brokerPeers := []string{testutil.GetLocalHost() + ":9092"} zkPeers := []string{testutil.GetLocalHost() + ":2181"} testTopic := fmt.Sprintf("telegraf_test_topic_%d", time.Now().Unix()) // Send a Kafka message to the kafka host msg := "cpu_load_short,direction=in,host=server01,region=us-west value=23422.0 1422568543702900257" producer, err := sarama.NewSyncProducer(brokerPeers, nil) require.NoError(t, err) _, _, err = producer.SendMessage( &sarama.ProducerMessage{ Topic: testTopic, Value: sarama.StringEncoder(msg), }) require.NoError(t, err) defer producer.Close() // Start the Kafka Consumer k := &Kafka{ ConsumerGroup: "telegraf_test_consumers", Topics: []string{testTopic}, ZookeeperPeers: zkPeers, PointBuffer: 100000, Offset: "oldest", } if err := k.Start(); err != nil { t.Fatal(err.Error()) } else { defer k.Stop() } waitForPoint(k, t) // Verify that we can now gather the sent message var acc testutil.Accumulator // Sanity check assert.Equal(t, 0, len(acc.Points), "There should not be any points") // Gather points err = k.Gather(&acc) require.NoError(t, err) if len(acc.Points) == 1 { point := acc.Points[0] assert.Equal(t, "cpu_load_short", point.Measurement) assert.Equal(t, map[string]interface{}{"value": 23422.0}, point.Fields) assert.Equal(t, map[string]string{ "host": "server01", "direction": "in", "region": "us-west", }, point.Tags) assert.Equal(t, time.Unix(0, 1422568543702900257).Unix(), point.Time.Unix()) } else { t.Errorf("No points found in accumulator, expected 1") } }
func (p *KafkaSender) Push(data map[string]interface{}) error { val := util.JsonString(data) _, _, err := producer.SendMessage(&sarama.ProducerMessage{ Topic: p.topic, Value: sarama.StringEncoder(val), }) return err }
// SendStringMessage sends a string message to kafka func (self *Kafka) SendStringMessage(msg string, event_type string) (partition int32, offset int64, err error) { if _, ok := self.topic[event_type]; !ok { event_type = "default" } message := &sarama.ProducerMessage{Topic: self.topic[event_type], Partition: self.partition} message.Value = sarama.StringEncoder(msg) return self.producer.SendMessage(message) }
func main() { flag.Parse() if *verbose { sarama.Logger = logger } var partitionerConstructor sarama.PartitionerConstructor switch *partitioner { case "hash": partitionerConstructor = sarama.NewHashPartitioner case "random": partitionerConstructor = sarama.NewRandomPartitioner default: log.Fatalf("Partitioner %s not supported.", *partitioner) } var keyEncoder, valueEncoder sarama.Encoder if *key != "" { keyEncoder = sarama.StringEncoder(*key) } if *value != "" { valueEncoder = sarama.StringEncoder(*value) } config := sarama.NewConfig() config.Producer.Partitioner = partitionerConstructor producer, err := sarama.NewSyncProducer(strings.Split(*brokerList, ","), config) if err != nil { logger.Fatalln("FAILED to open the producer:", err) } defer producer.Close() partition, offset, err := producer.SendMessage(&sarama.ProducerMessage{ Topic: *topic, Key: keyEncoder, Value: valueEncoder, }) if err != nil { logger.Println("FAILED to produce message:", err) } else { fmt.Printf("topic=%s\tpartition=%d\toffset=%d\n", *topic, partition, offset) } }
func (k *Kafka) Write(bp client.BatchPoints) error { if len(bp.Points) == 0 { return nil } var zero_time time.Time for _, p := range bp.Points { // Combine tags from Point and BatchPoints and grab the resulting // line-protocol output string to write to Kafka var value string if p.Raw != "" { value = p.Raw } else { for k, v := range bp.Tags { if p.Tags == nil { p.Tags = make(map[string]string, len(bp.Tags)) } p.Tags[k] = v } if p.Time == zero_time { if bp.Time == zero_time { p.Time = time.Now() } else { p.Time = bp.Time } } value = p.MarshalString() } m := &sarama.ProducerMessage{ Topic: k.Topic, Value: sarama.StringEncoder(value), } if h, ok := p.Tags[k.RoutingTag]; ok { m.Key = sarama.StringEncoder(h) } _, _, err := k.producer.SendMessage(m) if err != nil { return errors.New(fmt.Sprintf("FAILED to send kafka message: %s\n", err)) } } return nil }
func TestPartitioner(t *testing.T) { key := "aaa" var partitionNums int32 = 3 p := NewKafkaDefaultPartitioner("") m := &sarama.ProducerMessage{Key: sarama.StringEncoder(key)} pn, err := p.Partition(m, partitionNums) assert.Equal(t, nil, err) assert.Equal(t, c.JString(key).HashCode()%partitionNums, pn) }