How to develop a beat

type Beater interface {
        // The main event loop. This method should block until signalled to stop by an
        // invocation of the Stop() method.
        Run(b *Beat) error

        // Stop is invoked to signal that the Run method should finish its execution.
        // It will be invoked at most once.
        Stop()
}

package beater

//import relevant packages of libbeat, so we do not need to worry about configuration, logging etc.

import (
	"fmt"
	"time"

	"github.com/elastic/beats/libbeat/beat"
	"github.com/elastic/beats/libbeat/common"
	"github.com/elastic/beats/libbeat/logp"

	"github.com/luliang/custombeat/config"
)

// Custombeat configuration.
// define the struct for custom beat
// In this struct,
//    use pre-imported config.Config and beat.client.
//    use channel to receive exit signal.  

type Custombeat struct {
	done   chan struct{}
	config config.Config
	client beat.Client
}

// New creates an instance of custombeat.
func New(b *beat.Beat, cfg *common.Config) (beat.Beater, error) {
	c := config.DefaultConfig
	if err := cfg.Unpack(&c); err != nil {
		return nil, fmt.Errorf("Error reading config file: %v", err)
	}

	bt := &Custombeat{
		done:   make(chan struct{}),
		config: c,
	}
	return bt, nil
}

// Run starts custombeat.
func (bt *Custombeat) Run(b *beat.Beat) error {
	logp.Info("custombeat is running! Hit CTRL-C to stop it.")

	var err error
  // use beat.client to connect and publish data.
	bt.client, err = b.Publisher.Connect()
	if err != nil {
		return err
	}

  // get the time interval from config by using config.Config
	ticker := time.NewTicker(bt.config.Period)
	counter := 1
	for {
		select {
		case <-bt.done:
			return nil
		case <-ticker.C:
		}

    // generate event data
		event := beat.Event{
			Timestamp: time.Now(),
			Fields: common.MapStr{
				"type":    b.Info.Name,
				"counter": counter,
			},
		}

    // publish event data
		bt.client.Publish(event)
		logp.Info("Event sent")
		counter++
	}
}

// Stop stops custombeat.
func (bt *Custombeat) Stop() {
	bt.client.Close()
	close(bt.done)
}