func (o *HttpOutput) Init(config interface{}) (err error) {
o.HttpOutputConfig = config.(*HttpOutputConfig)
if o.url, err = url.Parse(o.Address); err != nil {
return fmt.Errorf("Can't parse URL '%s': %s", o.Address, err.Error())
}
if o.url.Scheme != "http" && o.url.Scheme != "https" {
return errors.New("`address` must contain an absolute http or https URL.")
}
o.Method = strings.ToUpper(o.Method)
if o.Method != "POST" && o.Method != "GET" && o.Method != "PUT" {
return errors.New("HTTP Method must be POST, GET, or PUT.")
}
if o.Method != "GET" {
o.sendBody = true
}
o.client = new(http.Client)
if o.HttpTimeout > 0 {
o.client.Timeout = time.Duration(o.HttpTimeout) * time.Millisecond
}
if o.Username != "" || o.Password != "" {
o.useBasicAuth = true
}
if o.url.Scheme == "https" {
transport := &http.Transport{}
if transport.TLSClientConfig, err = tcp.CreateGoTlsConfig(&o.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err.Error())
}
o.client.Transport = transport
}
return
}
func (ao *AMQPOutput) Init(config interface{}) (err error) {
conf := config.(*AMQPOutputConfig)
ao.config = conf
var tlsConf *tls.Config = nil
if strings.HasPrefix(conf.URL, "amqps://") && &ao.config.Tls != nil {
if tlsConf, err = tcp.CreateGoTlsConfig(&ao.config.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err)
}
}
var dialer = NewAMQPDialer(tlsConf)
if ao.amqpHub == nil {
ao.amqpHub = GetAmqpHub()
}
ch, usageWg, connectionWg, err := ao.amqpHub.GetChannel(conf.URL, dialer)
if err != nil {
return
}
ao.connWg = connectionWg
ao.usageWg = usageWg
closeChan := make(chan *amqp.Error)
ao.closeChan = ch.NotifyClose(closeChan)
err = ch.ExchangeDeclare(conf.Exchange, conf.ExchangeType,
conf.ExchangeDurability, conf.ExchangeAutoDelete, false, false,
nil)
if err != nil {
usageWg.Done()
return
}
ao.ch = ch
return
}
func (output *NsqOutput) SetNsqConfig(conf *NsqOutputConfig) (err error) {
nsqConfig := nsq.NewConfig()
if conf.ReadTimeout != nil {
nsqConfig.ReadTimeout = time.Duration(*conf.ReadTimeout) * time.Millisecond
}
if conf.WriteTimeout != nil {
nsqConfig.WriteTimeout = time.Duration(*conf.WriteTimeout) * time.Millisecond
}
if conf.ClientID != nil {
nsqConfig.ClientID = *conf.ClientID
}
if conf.Hostname != nil {
nsqConfig.Hostname = *conf.Hostname
}
if conf.UserAgent != nil {
nsqConfig.UserAgent = *conf.UserAgent
}
if conf.HeartbeatInterval != nil {
nsqConfig.HeartbeatInterval = time.Duration(*conf.HeartbeatInterval) * time.Millisecond
}
if conf.Deflate != nil {
nsqConfig.Deflate = *conf.Deflate
}
if conf.DeflateLevel != nil {
nsqConfig.DeflateLevel = *conf.DeflateLevel
}
if conf.Snappy != nil {
nsqConfig.Snappy = *conf.Snappy
}
if conf.OutputBufferSize != nil {
nsqConfig.OutputBufferSize = *conf.OutputBufferSize
}
if conf.OutputBufferTimeout != nil {
nsqConfig.OutputBufferTimeout = time.Duration(*conf.OutputBufferTimeout) * time.Millisecond
}
if conf.MaxInFlight != nil {
nsqConfig.MaxInFlight = *conf.MaxInFlight
}
if conf.MaxBackoffDuration != nil {
nsqConfig.MaxBackoffDuration = time.Duration(*conf.MaxBackoffDuration) * time.Millisecond
}
if conf.MsgTimeout != nil {
nsqConfig.MsgTimeout = time.Duration(*conf.MsgTimeout) * time.Millisecond
}
if conf.AuthSecret != nil {
nsqConfig.AuthSecret = *conf.AuthSecret
}
// Tls
if conf.UseTls {
tls, err := tcp.CreateGoTlsConfig(&conf.Tls)
if err != nil {
return err
}
output.config.TlsConfig = tls
}
output.config = nsqConfig
return
}
func (n *NagiosOutput) Init(config interface{}) (err error) {
n.conf = config.(*NagiosOutputConfig)
n.submitter = n.submitSendNsca
if n.conf.SendNscaBin == "" {
// HTTP is implied.
n.submitter = n.submitHttp
rht := time.Duration(n.conf.ResponseHeaderTimeout) * time.Second
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
ResponseHeaderTimeout: rht,
}
if n.conf.UseTls {
var tlsConf *tls.Config
if tlsConf, err = tcp.CreateGoTlsConfig(&n.conf.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err)
}
transport.TLSClientConfig = tlsConf
}
n.client = &http.Client{
Transport: transport,
}
}
return
}
func (o *ElasticSearchOutput) Init(config interface{}) (err error) {
o.conf = config.(*ElasticSearchOutputConfig)
o.batchChan = make(chan ESBatch)
o.backChan = make(chan []byte, 2)
o.recvChan = make(chan MsgPack, 100)
var serverUrl *url.URL
if serverUrl, err = url.Parse(o.conf.Server); err == nil {
var scheme string = strings.ToLower(serverUrl.Scheme)
switch scheme {
case "http", "https":
var tlsConf *tls.Config = nil
if scheme == "https" && &o.conf.Tls != nil {
if tlsConf, err = tcp.CreateGoTlsConfig(&o.conf.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err)
}
}
o.bulkIndexer = NewHttpBulkIndexer(scheme, serverUrl.Host, serverUrl.Path,
o.conf.FlushCount, o.conf.Username, o.conf.Password, o.conf.HTTPTimeout,
o.conf.HTTPDisableKeepalives, o.conf.ConnectTimeout, tlsConf)
case "udp":
o.bulkIndexer = NewUDPBulkIndexer(serverUrl.Host, o.conf.FlushCount)
default:
err = errors.New("Server URL must specify one of `udp`, `http`, or `https`.")
}
} else {
err = fmt.Errorf("Unable to parse ElasticSearch server URL [%s]: %s", o.conf.Server, err)
}
return
}
func (ai *AMQPInput) Init(config interface{}) (err error) {
conf := config.(*AMQPInputConfig)
ai.config = conf
var tlsConf *tls.Config = nil
if strings.HasPrefix(conf.URL, "amqps://") && &ai.config.Tls != nil {
if tlsConf, err = tcp.CreateGoTlsConfig(&ai.config.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err)
}
}
if ai.amqpHub == nil {
ai.amqpHub = getAmqpHub()
}
var dialer = AMQPDialer{tlsConf}
ch, usageWg, connWg, err := ai.amqpHub.GetChannel(conf.URL, dialer)
if err != nil {
return
}
var args amqp.Table
ttl := conf.QueueTTL
if ttl != -1 {
args = amqp.Table{"x-message-ttl": int32(ttl)}
}
defer func() {
if err != nil {
usageWg.Done()
}
}()
ai.connWg = connWg
ai.usageWg = usageWg
err = ch.ExchangeDeclare(conf.Exchange, conf.ExchangeType,
conf.ExchangeDurability, conf.ExchangeAutoDelete, false, false,
nil)
if err != nil {
return
}
ai.ch = ch
_, err = ch.QueueDeclare(conf.Queue, conf.QueueDurability,
conf.QueueAutoDelete, conf.QueueExclusive, false, args)
if err != nil {
return
}
err = ch.QueueBind(conf.Queue, conf.RoutingKey, conf.Exchange, false, nil)
if err != nil {
return
}
err = ch.Qos(conf.PrefetchCount, 0, false)
if err != nil {
return
}
return
}
func (t *TcpInput) setupTls(tomlConf *tcp.TlsConfig) (err error) {
if tomlConf.CertFile == "" || tomlConf.KeyFile == "" {
return errors.New("TLS config requires both cert_file and key_file value.")
}
var goConf *tls.Config
if goConf, err = tcp.CreateGoTlsConfig(tomlConf); err == nil {
t.listener = tls.NewListener(t.listener, goConf)
}
return
}
func createSender(test FloodTest) (sender *client.NetworkSender, err error) {
if test.UseTls {
var goTlsConfig *tls.Config
goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls)
if err != nil {
return
}
sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig)
} else {
sender, err = client.NewNetworkSender(test.Sender, test.IpAddress)
}
return
}
func (o *ElasticSearchOutput) Init(config interface{}) (err error) {
o.conf = config.(*ElasticSearchOutputConfig)
if !o.conf.UseBuffering {
o.batchChan = make(chan ESBatch)
o.backChan = make(chan []byte, 2)
}
o.outputExit = make(chan error)
var serverUrl *url.URL
if serverUrl, err = url.Parse(o.conf.Server); err == nil {
var scheme string = strings.ToLower(serverUrl.Scheme)
switch scheme {
case "http", "https":
var tlsConf *tls.Config = nil
if scheme == "https" && &o.conf.Tls != nil {
if tlsConf, err = tcp.CreateGoTlsConfig(&o.conf.Tls); err != nil {
return fmt.Errorf("TLS init error: %s", err)
}
}
o.bulkIndexer = NewHttpBulkIndexer(scheme, serverUrl.Host,
o.conf.FlushCount, o.conf.Username, o.conf.Password, o.conf.HTTPTimeout,
o.conf.HTTPDisableKeepalives, o.conf.ConnectTimeout, tlsConf)
case "udp":
o.bulkIndexer = NewUDPBulkIndexer(serverUrl.Host, o.conf.FlushCount)
default:
err = errors.New("Server URL must specify one of `udp`, `http`, or `https`.")
}
} else {
err = fmt.Errorf("Unable to parse ElasticSearch server URL [%s]: %s", o.conf.Server, err)
}
switch o.conf.QueueFullAction {
case "shutdown", "drop", "block":
default:
return fmt.Errorf("`queue_full_action` must be 'shutdown', 'drop', or 'block', got %s",
o.conf.QueueFullAction)
}
return
}
// NewIrcConn creates an *irc.Connection. It handles using Heka's tcp plugin to
// create a cryto/tls config
func NewIrcConn(config *IrcOutputConfig) (IrcConnection, error) {
conn := irc.IRC(config.Nick, config.Ident)
if conn == nil {
return nil, errors.New("Nick or Ident cannot be blank")
}
if config.Server == "" {
return nil, errors.New("Irc server cannot be blank.")
}
if len(config.Channels) < 1 {
return nil, errors.New("Need at least 1 channel to join.")
}
var tlsConf *tls.Config = nil
var err error = nil
if tlsConf, err = tcp.CreateGoTlsConfig(&config.Tls); err != nil {
return nil, fmt.Errorf("TLS init error: %s", err)
}
conn.UseTLS = config.UseTLS
conn.TLSConfig = tlsConf
conn.Password = config.Password
conn.Timeout = time.Duration(config.Timeout) * time.Second
conn.VerboseCallbackHandler = config.VerboseIRCLogging
return conn, nil
}
func main() {
configFile := flag.String("config", "flood.toml", "Heka Flood configuration file")
configTest := flag.String("test", "default", "Test section to load")
flag.Parse()
if flag.NFlag() == 0 {
flag.PrintDefaults()
os.Exit(0)
}
var config FloodConfig
if _, err := toml.DecodeFile(*configFile, &config); err != nil {
client.LogError.Printf("Error decoding config file: %s", err)
return
}
var test FloodTest
var ok bool
if test, ok = config[*configTest]; !ok {
client.LogError.Printf("Configuration test: '%s' was not found", *configTest)
return
}
if test.MsgInterval != "" {
var err error
if test.msgInterval, err = time.ParseDuration(test.MsgInterval); err != nil {
client.LogError.Printf("Invalid message_interval duration %s: %s", test.MsgInterval,
err.Error())
return
}
}
if test.PprofFile != "" {
profFile, err := os.Create(test.PprofFile)
if err != nil {
client.LogError.Fatalln(err)
}
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
if test.MaxMessageSize > 0 {
message.SetMaxMessageSize(test.MaxMessageSize)
}
var sender *client.NetworkSender
var err error
if test.UseTls {
var goTlsConfig *tls.Config
goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls)
if err != nil {
client.LogError.Fatalf("Error creating TLS config: %s\n", err)
}
sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig)
} else {
sender, err = client.NewNetworkSender(test.Sender, test.IpAddress)
}
if err != nil {
client.LogError.Fatalf("Error creating sender: %s\n", err)
}
unsignedEncoder := client.NewProtobufEncoder(nil)
signedEncoder := client.NewProtobufEncoder(&test.Signer)
oversizedEncoder := &OversizedEncoder{}
var numTestMessages = 1
var unsignedMessages [][]byte
var signedMessages [][]byte
var oversizedMessages [][]byte
rdm := &randomDataMaker{
src: rand.NewSource(time.Now().UnixNano()),
asciiOnly: test.AsciiOnly,
}
if test.VariableSizeMessages {
numTestMessages = 64
unsignedMessages = makeVariableMessage(unsignedEncoder, numTestMessages, rdm, false)
signedMessages = makeVariableMessage(signedEncoder, numTestMessages, rdm, false)
oversizedMessages = makeVariableMessage(oversizedEncoder, 1, rdm, true)
} else {
if test.StaticMessageSize == 0 {
test.StaticMessageSize = 1000
}
unsignedMessages = makeFixedMessage(unsignedEncoder, test.StaticMessageSize,
rdm)
signedMessages = makeFixedMessage(signedEncoder, test.StaticMessageSize,
rdm)
}
// wait for sigint
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT)
var msgsSent, bytesSent, msgsDelivered uint64
var corruptPercentage, lastCorruptPercentage, signedPercentage, lastSignedPercentage, oversizedPercentage, lastOversizedPercentage float64
var corrupt bool
// set up counter loop
ticker := time.NewTicker(time.Duration(time.Second))
go timerLoop(&msgsSent, &bytesSent, ticker)
test.CorruptPercentage /= 100.0
test.SignedPercentage /= 100.0
test.OversizedPercentage /= 100.0
var buf []byte
for gotsigint := false; !gotsigint; {
runtime.Gosched()
select {
case <-sigChan:
gotsigint = true
continue
default:
}
msgId := rand.Int() % numTestMessages
corruptPercentage = math.Floor(float64(msgsSent) * test.CorruptPercentage)
if corruptPercentage != lastCorruptPercentage {
lastCorruptPercentage = corruptPercentage
corrupt = true
} else {
corrupt = false
}
signedPercentage = math.Floor(float64(msgsSent) * test.SignedPercentage)
if signedPercentage != lastSignedPercentage {
lastSignedPercentage = signedPercentage
buf = signedMessages[msgId]
} else {
oversizedPercentage = math.Floor(float64(msgsSent) * test.OversizedPercentage)
if oversizedPercentage != lastOversizedPercentage {
lastOversizedPercentage = oversizedPercentage
buf = oversizedMessages[0]
} else {
buf = unsignedMessages[msgId]
}
}
bytesSent += uint64(len(buf))
if err = sendMessage(sender, buf, corrupt); err != nil {
client.LogError.Printf("Error sending message: %s\n", err.Error())
} else {
msgsDelivered++
}
msgsSent++
if test.NumMessages != 0 && msgsSent >= test.NumMessages {
break
}
if test.msgInterval != 0 {
time.Sleep(test.msgInterval)
}
}
sender.Close()
client.LogInfo.Println("Clean shutdown: ", msgsSent, " messages sent; ",
msgsDelivered, " messages delivered.")
}
func main() {
configFile := flag.String("config", "sbmgr.toml", "Sandbox manager configuration file")
scriptFile := flag.String("script", "xyz.lua", "Sandbox script file")
scriptConfig := flag.String("scriptconfig", "xyz.toml", "Sandbox script configuration file")
filterName := flag.String("filtername", "filter", "Sandbox filter name (used on unload)")
action := flag.String("action", "load", "Sandbox manager action")
flag.Parse()
var config SbmgrConfig
if _, err := toml.DecodeFile(*configFile, &config); err != nil {
client.LogError.Printf("Error decoding config file: %s", err)
return
}
var sender *client.NetworkSender
var err error
if config.UseTls {
var goTlsConfig *tls.Config
goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls)
if err != nil {
client.LogError.Fatalf("Error creating TLS config: %s\n", err)
}
sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig)
} else {
sender, err = client.NewNetworkSender("tcp", config.IpAddress)
}
if err != nil {
client.LogError.Fatalf("Error creating sender: %s\n", err.Error())
}
encoder := client.NewProtobufEncoder(&config.Signer)
manager := client.NewClient(sender, encoder)
hostname, _ := os.Hostname()
msg := &message.Message{}
msg.SetLogger(pipeline.HEKA_DAEMON) // identify the message as 'internal' for filtering purposes
msg.SetType("heka.control.sandbox")
msg.SetTimestamp(time.Now().UnixNano())
msg.SetUuid(uuid.NewRandom())
msg.SetHostname(hostname)
switch *action {
case "load":
code, err := ioutil.ReadFile(*scriptFile)
if err != nil {
client.LogError.Printf("Error reading scriptFile: %s\n", err.Error())
return
}
msg.SetPayload(string(code))
conf, err := ioutil.ReadFile(*scriptConfig)
if err != nil {
client.LogError.Printf("Error reading scriptConfig: %s\n", err.Error())
return
}
f, _ := message.NewField("config", string(conf), "toml")
msg.AddField(f)
case "unload":
f, _ := message.NewField("name", *filterName, "")
msg.AddField(f)
default:
client.LogError.Printf("Invalid action: %s", *action)
}
f1, _ := message.NewField("action", *action, "")
msg.AddField(f1)
err = manager.SendMessage(msg)
if err != nil {
client.LogError.Printf("Error sending message: %s\n", err.Error())
}
}
func (input *NsqInput) SetNsqConfig(conf *NsqInputConfig) (err error) {
nsqConfig := nsq.NewConfig()
if conf.LookupdPollInterval != nil {
nsqConfig.LookupdPollInterval = time.Duration(*conf.LookupdPollInterval) * time.Millisecond
}
if conf.LookupdPollJitter != nil {
nsqConfig.LookupdPollJitter = *conf.LookupdPollJitter
}
if conf.MaxRequeueDelay != nil {
nsqConfig.MaxRequeueDelay = time.Duration(*conf.MaxRequeueDelay) * time.Millisecond
}
if conf.DefaultRequeueDelay != nil {
nsqConfig.DefaultRequeueDelay = time.Duration(*conf.DefaultRequeueDelay) * time.Millisecond
}
if conf.BackoffMultiplier != nil {
nsqConfig.BackoffMultiplier = time.Duration(*conf.BackoffMultiplier) * time.Millisecond
}
if conf.MaxAttempts != nil {
nsqConfig.MaxAttempts = *conf.MaxAttempts
}
if conf.LowRdyIdleTimeout != nil {
nsqConfig.LowRdyIdleTimeout = time.Duration(*conf.LowRdyIdleTimeout) * time.Millisecond
}
if conf.SampleRate != nil {
nsqConfig.SampleRate = *conf.SampleRate
}
if conf.ReadTimeout != nil {
nsqConfig.ReadTimeout = time.Duration(*conf.ReadTimeout) * time.Millisecond
}
if conf.WriteTimeout != nil {
nsqConfig.WriteTimeout = time.Duration(*conf.WriteTimeout) * time.Millisecond
}
if conf.ClientID != nil {
nsqConfig.ClientID = *conf.ClientID
}
if conf.Hostname != nil {
nsqConfig.Hostname = *conf.Hostname
}
if conf.UserAgent != nil {
nsqConfig.UserAgent = *conf.UserAgent
}
if conf.HeartbeatInterval != nil {
nsqConfig.HeartbeatInterval = time.Duration(*conf.HeartbeatInterval) * time.Millisecond
}
if conf.Deflate != nil {
nsqConfig.Deflate = *conf.Deflate
}
if conf.DeflateLevel != nil {
nsqConfig.DeflateLevel = *conf.DeflateLevel
}
if conf.Snappy != nil {
nsqConfig.Snappy = *conf.Snappy
}
if conf.OutputBufferSize != nil {
nsqConfig.OutputBufferSize = *conf.OutputBufferSize
}
if conf.OutputBufferTimeout != nil {
nsqConfig.OutputBufferTimeout = time.Duration(*conf.OutputBufferTimeout) * time.Millisecond
}
if conf.MaxInFlight != nil {
nsqConfig.MaxInFlight = *conf.MaxInFlight
}
if conf.MaxBackoffDuration != nil {
nsqConfig.MaxBackoffDuration = time.Duration(*conf.MaxBackoffDuration) * time.Millisecond
}
if conf.MsgTimeout != nil {
nsqConfig.MsgTimeout = time.Duration(*conf.MsgTimeout) * time.Millisecond
}
if conf.AuthSecret != nil {
nsqConfig.AuthSecret = *conf.AuthSecret
}
// Tls
if conf.UseTls {
tls, err := tcp.CreateGoTlsConfig(&conf.Tls)
if err != nil {
return err
}
input.config.TlsConfig = tls
}
input.config = nsqConfig
return
}
func main() {
configFile := flag.String("config", "sbmgrload.toml", "Sandbox manager load configuration file")
action := flag.String("action", "load", "load/unload")
numItems := flag.Int("num", 1, "Number of sandboxes to load/unload")
flag.Parse()
code := `
require "string"
require "table"
require "os"
lastTime = os.time() * 1e9
lastCount = 0
count = 0
rate = 0.0
rates = {}
function process_message ()
count = count + 1
return 0
end
function timer_event(ns)
local msgsSent = count - lastCount
if msgsSent == 0 then return end
local elapsedTime = ns - lastTime
if elapsedTime == 0 then return end
lastCount = count
lastTime = ns
rate = msgsSent / (elapsedTime / 1e9)
rates[#rates+1] = rate
output(string.format("Got %d messages. %0.2f msg/sec", count, rate))
inject_message()
local samples = #rates
if samples == 10 then -- generate a summary every 10 samples
table.sort(rates)
local min = rates[1]
local max = rates[samples]
local sum = 0
for i, val in ipairs(rates) do
sum = sum + val
end
output(string.format("AGG Sum. Min: %0.2f Max: %0.2f Mean: %0.2f", min, max, sum/samples))
inject_message()
rates = {}
end
end
`
confFmt := `
[CounterSandbox%d]
type = "SandboxFilter"
message_matcher = "Type == 'hekabench'"
ticker_interval = 1
script_type = "lua"
filename = ""
preserve_data = true
`
var config SbmgrConfig
if _, err := toml.DecodeFile(*configFile, &config); err != nil {
log.Printf("Error decoding config file: %s", err)
return
}
var sender *client.NetworkSender
var err error
if config.UseTls {
var goTlsConfig *tls.Config
goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls)
if err != nil {
log.Fatalf("Error creating TLS config: %s\n", err)
}
sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig)
} else {
sender, err = client.NewNetworkSender("tcp", config.IpAddress)
}
if err != nil {
log.Fatalf("Error creating sender: %s\n", err.Error())
}
encoder := client.NewProtobufEncoder(&config.Signer)
manager := client.NewClient(sender, encoder)
hostname, _ := os.Hostname()
switch *action {
case "load":
for i := 0; i < *numItems; i++ {
conf := fmt.Sprintf(confFmt, i)
msg := &message.Message{}
msg.SetType("heka.control.sandbox")
msg.SetTimestamp(time.Now().UnixNano())
msg.SetUuid(uuid.NewRandom())
msg.SetHostname(hostname)
msg.SetPayload(code)
f, _ := message.NewField("config", conf, "toml")
msg.AddField(f)
f1, _ := message.NewField("action", *action, "")
msg.AddField(f1)
err = manager.SendMessage(msg)
if err != nil {
log.Printf("Error sending message: %s\n", err.Error())
}
}
case "unload":
for i := 0; i < *numItems; i++ {
msg := &message.Message{}
msg.SetType("heka.control.sandbox")
msg.SetTimestamp(time.Now().UnixNano())
msg.SetUuid(uuid.NewRandom())
msg.SetHostname(hostname)
f, _ := message.NewField("name", fmt.Sprintf("CounterSandbox%d", i), "")
msg.AddField(f)
f1, _ := message.NewField("action", *action, "")
msg.AddField(f1)
err = manager.SendMessage(msg)
if err != nil {
log.Printf("Error sending message: %s\n", err.Error())
}
}
default:
log.Printf("Invalid action: %s\n", *action)
}
}
func (o *InfluxDBOutput) Init(config interface{}) error {
conf := config.(*InfluxDBOutputConfig)
serverUrl, err := url.Parse(conf.Server)
if err != nil {
return fmt.Errorf("Unable to parse InfluxDB server URL (%s): %s", conf.Server, err)
}
switch strings.ToLower(serverUrl.Scheme) {
case "http", "https":
serverUrl.Path = path.Join(serverUrl.Path, "db", url.QueryEscape(conf.Database), "series")
vals := serverUrl.Query()
vals.Set("time_precision", "u") // microseconds
if conf.Username != "" {
vals.Set("u", conf.Username)
}
if conf.Password != "" {
vals.Set("p", conf.Password)
}
serverUrl.RawQuery = vals.Encode()
default:
return fmt.Errorf("Unable to handle server URL scheme %r", serverUrl.Scheme)
}
o.seriesUrl = serverUrl.String()
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
ResponseHeaderTimeout: time.Duration(conf.ResponseHeaderTimeout) * time.Second,
}
if serverUrl.Scheme == "https" {
tlsConf, err := hekaTcp.CreateGoTlsConfig(&conf.Tls)
if err != nil {
return fmt.Errorf("Error settings TLS configuration: %s", err)
}
transport.TLSClientConfig = tlsConf
}
o.httpClient = &http.Client{Transport: transport}
if conf.Series == "" && conf.FieldMap["series"] == "" {
return fmt.Errorf("Must set series or field_map.series")
}
o.series = conf.Series
if conf.UseHekaTimestamp {
_, hasTime := conf.FieldMap["time"]
if !hasTime {
o.columns = []string{"time"}
o.columnFields = []string{"_hekaTimestampMicro"}
}
}
for column, field := range conf.FieldMap {
if column == "series" {
o.seriesField = field
continue
}
o.columns = append(o.columns, column)
o.columnFields = append(o.columnFields, field)
}
o.flushInterval = time.Duration(conf.FlushInterval) * time.Millisecond
o.flushCount = conf.FlushCount
return nil
}