antecedente comentário
Nós previamente concluído implementações de lógica de consumo kafka, e colocar notícias ElasticSearch, então confira nossas ferramentas de visualização de registros Kibana.
Esta meta secção
Anteriormente apenas o consumo de notícias kafka acabado, e colocar elástico, isso vai melhorar o projeto para que ele suporta atualização quente é que quando config.yaml em monitorar o log de alterações, ou dados ETCD mudou iniciar dinamicamente monitor de nova co-rotina log perto cancelar a co-rotina de monitorização de log.
Nova Co Chengzi Qi de variável de comando móvel
Adicione o seguinte código kafkaconsumer.go
var topicMap map [cadeia] map [int32] * TopicData
var topicSet mapa [cadeia] bool
var etcd_topicSet mapa [cadeia] bool
var etcd_topicMap mapa [cadeia] map [int32] * TopicData
var topicChan chan * TopicPart
var etcd_topicChan chan * TopicPart
var consumer_list [] sarama.Consumer
var etcdcli * clientv3.Client
Init func () {
topicMap = make (mapa [cadeia] map [int32] * TopicData)
etcd_topicMap = make (Mapa Mapa [cadeia] [int32] * TopicData)
topicSet = make (mapa [cadeia] bool)
etcd_topicSet = make (mapa [cadeia] bool)
topicChan = marca (Chan * TopicPart, 20)
etcd_topicChan = marca (Chan * TopicPart, 20)
consumer_list = marca ([] sarama.Consumer, 0, 20)
}
topicMap tema e para parâmetros de registro armazenados config.yaml coroutine registrados diretamente, etcd_topicMap utilizada para gravar e parâmetros tópico ETCD coroutine gravado.
topicSet para registro tópico config.yaml registrados diretamente, etcd_topicSet tópico ETCD para gravação gravado.
Quando o monitoramento topicChan log write anormal acidente coroutine elástico, para retornar as informações tópico Chan, que, em seguida, encontrar o tópico correspondente reiniciado com o topicMap coroutine.
O tópico etcd_topicChan co-rotina armazenada ETCD, o processo etlastic monitoramento, se as falhas co-rotina, etcd_topicMap encontrar o tópico correspondente reiniciado com o co-rotina.
consumer_list salvo kafka lista de consumidores.
ETCD etcdcli o cliente para lidar com leitor de ETCD.
O tópico conjunto configurado de registo de configuração gerado
func ConstructTopicSet () map [cadeia] bool {
topicSetTmp: = make (mapa [cadeia] bool)
configtopics, _: = logconfig.ReadConfig (logconfig.InitVipper (), "collectlogs")
se configtopics == nil {
Goto CONFTOPIC
}
para _, configtopic: = variar configtopics ([] de interface {}) {.
confmap:. = configtopic (mapa [interface {}] de interface {})
para a chave, val: = confmap gama {
se a chave. (string) == "logtopic" {
topicSetTmp [val. (string)] = true
}
}
}
CONFTOPIC:
retorno topicSetTmp
}
etcdconsumer.go GetTopicSet lido pelo tema da vida e conjunto de ETCD
val aquisição de acordo ETCD configuração configurado chave, e, em seguida, gera um tópico conjunto adquirido
func GetTopicSet (cli * clientv3.Client) (Interface {}, erro) {
etcdKeys, etcdres: = logconfig.ReadConfig (logconfig.InitVipper (), "etcdkeys")
se! etcdres {
fmt.Println ( "etcdkeys configuração de leitura falhou")
retorno nulo, errors.New ( "etcdkeys configuração de leitura falhou")
}
fmt.Println (reflect.TypeOf (etcdKeys))
topicSet: = make (mapa [cadeia] bool)
para _, keyval: = variar etcdKeys ([] de interface {}) {.
ctxtime, cancelar: = context.WithTimeout (context.Background (), time.Second)
resp, err: = cli.Get (. ctxtime, keyval (string))
cancelar()
se err! = nil {
fmt.Println ( "se falhou, err:" err)
continuar
}
para _, ev: = variam resp.Kvs {
fmt.Printf ( "% s:% s ... \ n", ev.Key, ev.Value)
etcdLogConf: = marca ([] * etcdlogconf.EtcdLogConf, 0, 20)
unmarsherr: = json.Unmarshal (ev.Value, & etcdLogConf)
se unmarsherr! = nil {
fmt.Println ( "erro unmarshal!, o erro é", unmarsherr)
continuar
}
para _, etcdval: = variam etcdLogConf {
topicSet [etcdval.Topic] = verdadeira
}
}
}
retorno topicSet, nil
}
Situado no mapa, e, em seguida, começa a co-rotina de configuração
func ConvertSet2Map (consumidor sarama.Consumer, topicSet mapa [cadeia] bool,
topicMaps map [cadeia] map [int32] * TopicData, topic_chan chan * TopicPart) {
para a chave, _: = topicSet gama {
partitionList, err: = consumer.Partitions (chave)
se err! = nil {
fmt.Println ( "se partições de consumo falhou")
fmt.Println ( "erro é", err.Error ())
continuar
}
para partição: = variar partitionList {
pc, err: = consumer.ConsumePartition (chave, int32 (partição), sarama.OffsetNewest)
se err! = nil {
fmt.Println ( "consumir erro da divisória é", err.Error ())
continuar
}
// pc.AsyncClose defer ()
topicData: = novo (TopicData)
topicData.Ctx, topicData.Cancel = context.WithCancel (context.Background ())
topicData.KafConsumer = pc
topicData.TPartition = novo (TopicPart)
topicData.TPartition.Partition = int32 (partição)
topicData.TPartition.Topic = chave
_, Okm: topicMaps = [key]
se! OKM {
topicMaps [key] = make (mapa [int32] * TopicData)
}
topicMaps [chave] [int32 (partição)] = topicData
Go PutIntoES (topicData, topic_chan)
}
}
}
Kafka lido a partir da mensagem, e chamar a função acima inicia monitoramento es coroutine
Kafka ler informação a partir de, e, em seguida, gera um conjunto de mapas de acordo com a configuração e iniciar a monitorização de es co-rotina
func ConsumeTopic (sarama.Consumer consumidor) {
ConvertSet2Map (consumidor, topicSet, topicMap, topicChan)
ConvertSet2Map (consumidor, etcd_topicSet, etcd_topicMap, etcd_topicChan)
// Ouça perfil
CTX, cancelar: = context.WithCancel (context.Background ())
pathChan: = make (chan de interface {})
etcdChan: = make (chan de interface {})
go logconfig.WatchConfig (CTX, logconfig.InitVipper (), pathChan, etcdChan)
adiar func (cancelar context.CancelFunc) {
consumer_once.Do (func () {
Se err: = recuperar (); err! = nil {
fmt.Println ( "principal consumidor de pânico goroutine", err)
}
cancelar()
})
}(cancelar)
para {
selecionar {
// caminho detectado monitoramento acidente coroutine, reinicialização
caso topicpart: = <-topicChan:
fmt.Printf ( "receber goroutine saiu, tópico é% s, partição é% d \ n",
topicpart.Topic, topicpart.Partition)
// reinício consumidores ler coroutine dados
val, ok: = topicMap [topicpart.Topic]
se! ok {
continuar
}
tp, ok: = val [topicpart.Partition]
se! ok {
continuar
}
tp.Ctx, tp.Cancel = context.WithCancel (context.Background ())
go PutIntoES (tp, topicChan)
Depois de detectar ETCD // análise de configuração, monitoramento acidente coroutine caminho, reinicialização
caso topicpart: = <-etcd_topicChan:
fmt.Printf ( "receber goroutine saiu, tópico é% s, partição é% d \ n",
topicpart.Topic, topicpart.Partition)
// reinício consumidores ler coroutine dados
val, ok: = etcd_topicMap [topicpart.Topic]
se! ok {
continuar
}
tp, ok: = val [topicpart.Partition]
se! ok {
continuar
}
tp.Ctx, tp.Cancel = context.WithCancel (context.Background ())
go PutIntoES (tp, etcd_topicChan)
// retorna a configuração dos detecta monitorar VIPPER atualização
caso pathchange, ok: = <-pathChan:
se! ok {
fmt.Println ( "relógio VIPPER goroutine saiu")
Goto LoopEnd
}
//fmt.Println(pathchange)
topicSetTemp: = make (mapa [cadeia] bool)
para _, chval:. = pathchange gama ([] de interface {}) {
para logkey, logval: = variar chval (interface do mapa [interface {}]} {) {.
se logkey. (string) == "logtopic" {
topicSetTemp [logval. (string)] = true
}
}
}
UpdateTopicLogRoutine (topicSetTemp)
//fmt.Println(topicSetTemp)
caso etcdchange, ok: = <-etcdChan:
se! ok {
fmt.Println ( "relógio VIPPER goroutine extied")
Goto LoopEnd
}
fmt.Println (etcdchange)
topicsetTemp, err: = etcdconsumer.GetTopicSet (etcdcli)
se err! = nil {
continuar
}
UpdateEtcdTopicLogRoutine (topicsetTemp. (Mapa [cadeia] bool))
}
}
LoopEnd:
fmt.Printf ( "por encerrado")
}
go logconfig.WatchConfig coroutine início, configuração do monitor chamada VIPPER, tema quando equipado com atualizações de manipulação atualizados coroutine consumidor.
Ao mesmo tempo em que a sustentação de criança coroutine colapso anormal, coroutine consumidor reiniciar a co-rotina.
Por informações de log Kibana
Kibana na gestão e novo índice, elástica é o índice que set tópico, por isso temos um novo índice poucos,
etcd_log, golang_log, logdir2.
Então Kibana pode ser visto em vários das informações de log índice
Download fonte
https://github.com/secondtonone1/golang-/tree/master/logcatchsys
agradecer a minha preocupação pública Não.