├── Makefile
├── README.md
├── circle.yml
├── docker-image
    ├── Dockerfile
    └── etc
    │   ├── fluent-bit-forwarder.conf
    │   ├── fluent-bit.conf
    │   └── parsers.conf
├── flatten.go
├── fluent-bit-daemonset.yaml
├── glide.lock
├── glide.yaml
└── out_sls.go


/Makefile:
--------------------------------------------------------------------------------
 1 | DOCKER_IMAGE_NAME       ?= archon-controller
 2 | DOCKER_IMAGE_TAG        ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))
 3 | 
 4 | all: glide plugin
 5 | 
 6 | glide:
 7 | 	glide install
 8 | 
 9 | plugin:
10 | 	go build -buildmode=c-shared -o out_sls.so .
11 | 	cp out_sls.so docker-image/
12 | 
13 | clean:
14 | 	rm -rf *.so *.h *~
15 | 
16 | docker:
17 | 	@echo ">> building docker image"
18 | 	@docker build -t "$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" docker-image
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Fluent Bit Aliyun
 2 | 
 3 | [![CircleCI](https://circleci.com/gh/kubeup/fluent-bit-aliyun/tree/master.svg?style=shield)](https://circleci.com/gh/kubeup/fluent-bit-aliyun)
 4 | 
 5 | Fluent Bit output plugin which sends logs to [Aliyun Simple Log Service(SLS)](https://cn.aliyun.com/product/sls).
 6 | You can do realtime analysis and archiving using other Aliyun products. Check Aliyun
 7 | documents for detailed usage.
 8 | 
 9 | ## Installing
10 | 
11 | Currently we only provide Docker image for Linux machines at [Docker Hub](https://hub.docker.com/r/kubeup/fluent-bit-aliyun/).
12 | If you're not using Docker, you can compile the plugin from source.
13 | 
14 | ### Docker
15 | 
16 | Docker supports fluentd as a log driver. You can launch `fluent-bit-aliyun` in a container
17 | and ask Docker to send logs to it.
18 | 
19 | ```
20 | $ docker run -d --network host -e ALIYUN_ACCESS_KEY=YOUR_ACCESS_KEY -e ALIYUN_ACCESS_KEY_SECRET=YOUR_ACCESS_KEY_SECRET -e ALIYUN_SLS_PROJECT=YOUR_PROJECT -e ALIYUN_SLS_LOGSTORE=YOUR_LOGSTORE -e ALIYUN_SLS_ENDPOINT=cn-hangzhou.log.aliyuncs.com kubeup/fluent-bit-aliyun:v0.1.0 /fluent-bit/bin/fluent-bit -c /fluent-bit/etc/fluent-bit-forwarder.conf -e /fluent-bit/out_sls.so
21 | $ docker run --log-driver=fluentd -d nginx
22 | ```
23 | 
24 | You can also set fluentd as your default log driver by adding `--log-driver=fluentd`
25 | to Docker daemon.
26 | 
27 | ### Kubernetes
28 | 
29 | We use `DaemonSet` to deploy `fluent-bit-aliyun` on all nodes which will collect Docker
30 | logs from all pods on each machine. The `kubernetes` filter will add tags from pod metadata.
31 | 
32 | First we create a `Secret` containing all the configurations.
33 | 
34 | ```
35 | $ kubectl create secret generic fluent-bit-config --namespace=kube-system --from-literal=ALIYUN_ACCESS_KEY=YOUR_ACCESS_KEY --from-literal=ALIYUN_ACCESS_KEY_SECRET=YOUR_ACCESS_KEY_SECRET --from-literal=ALIYUN_SLS_PROJECT=YOUR_PROJECT --from-literal=ALIYUN_SLS_LOGSTORE=YOUR_LOGSTORE --from-literal=ALIYUN_SLS_ENDPOINT=cn-hangzhou.log.aliyuncs.com
36 | ```
37 | 
38 | Then we deploy the `DaemonSet`.
39 | 
40 | ```
41 | $ kubectl create -f https://raw.githubusercontent.com/kubeup/fluent-bit-aliyun/master/fluent-bit-daemonset.yaml
42 | ```
43 | 
44 | We could check the status.
45 | 
46 | ```
47 | $ kubectl get pods --namespace=kube-system
48 | ```
49 | 
50 | ## Configurations
51 | 
52 | You can config the plugin using environment variables. We support these configs:
53 | 
54 | - ALIYUN_ACCESS_KEY
55 | - ALIYUN_ACCESS_KEY_SECRET 
56 | - ALIYUN_SLS_PROJECT
57 | - ALIYUN_SLS_LOGSTORE
58 | - ALIYUN_SLS_ENDPOINT
59 | 
60 | You should consider creating a dedicated account in [RAM](https://cn.aliyun.com/product/ram)
61 | just for logging for better security protection.
62 | 


--------------------------------------------------------------------------------
/circle.yml:
--------------------------------------------------------------------------------
 1 | machine:
 2 |   environment:
 3 |     DOCKER_IMAGE_NAME: kubeup/fluent-bit-aliyun
 4 |     USER: kubeup
 5 |     REPO: fluent-bit-aliyun
 6 |   pre:
 7 |     - sudo curl -L -o /usr/bin/docker 'https://s3-external-1.amazonaws.com/circle-downloads/docker-1.9.1-circleci'
 8 |     - sudo chmod 0755 /usr/bin/docker
 9 |     - sudo curl -L 'https://github.com/aktau/github-release/releases/download/v0.6.2/linux-amd64-github-release.tar.bz2' | tar xvjf - --strip-components 3 -C $HOME/bin
10 |     - sudo curl -L 'https://github.com/Masterminds/glide/releases/download/v0.12.3/glide-v0.12.3-linux-amd64.tar.gz' | tar xvzf - -C $HOME/bin
11 |     - sudo mv $HOME/bin/linux-amd64/glide $HOME/bin/
12 |   services:
13 |     - docker
14 | 
15 | dependencies:
16 |   pre:
17 |     - docker info
18 |   override:
19 |     - mkdir -p $HOME/.go_workspace/src/github.com/kubeup
20 |     - ln -sf $HOME/$CIRCLE_PROJECT_REPONAME $HOME/.go_workspace/src/github.com/kubeup/$CIRCLE_PROJECT_REPONAME
21 |     - glide install
22 |     - go build -buildmode=c-shared -o out_sls.so github.com/kubeup/fluent-bit-aliyun
23 |     - cp out_sls.so docker-image/
24 |     - |
25 |       if [ -n "$CIRCLE_TAG" ]; then
26 |         make docker DOCKER_IMAGE_NAME=$DOCKER_IMAGE_NAME DOCKER_IMAGE_TAG=$CIRCLE_TAG
27 |       else
28 |         make docker DOCKER_IMAGE_NAME=$DOCKER_IMAGE_NAME
29 |       fi
30 |   post:
31 |     - docker images
32 | 
33 | test:
34 |   override:
35 |     - go test github.com/kubeup/fluent-bit-aliyun
36 | 
37 | deployment:
38 |   hub_branch:
39 |     branch: master
40 |     owner: kubeup
41 |     commands:
42 |       - docker login -e $DOCKER_EMAIL -u $DOCKER_LOGIN -p $DOCKER_PASSWORD
43 |       - docker push $DOCKER_IMAGE_NAME
44 |   hub_tag:
45 |     tag: /^v[0-9]+(\.[0-9]+){2}(-.+|[^-.]*)$/
46 |     owner: kubeup
47 |     commands:
48 |       - docker login -e $DOCKER_EMAIL -u $DOCKER_LOGIN -p $DOCKER_PASSWORD
49 |       - docker push $DOCKER_IMAGE_NAME
50 | 


--------------------------------------------------------------------------------
/docker-image/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM fluent/fluent-bit:0.11
2 | USER root
3 | COPY etc /fluent-bit/etc/
4 | COPY out_sls.so /fluent-bit/
5 | CMD ["/fluent-bit/bin/fluent-bit", "-c", "/fluent-bit/etc/fluent-bit.conf", "-e", "/fluent-bit/out_sls.so"]
6 | 


--------------------------------------------------------------------------------
/docker-image/etc/fluent-bit-forwarder.conf:
--------------------------------------------------------------------------------
 1 | [SERVICE]
 2 |     Flush          1
 3 |     Daemon         Off
 4 |     Log_Level      info
 5 |     Parsers_File   parsers.conf
 6 | 
 7 | [INPUT]
 8 |     Name        forward
 9 |     Listen      0.0.0.0
10 |     Port        24224
11 |     Chunk_Size  32
12 |     Buffer_Size 64
13 | 
14 | [OUTPUT]
15 |     Name   sls
16 |     Match  *
17 | 


--------------------------------------------------------------------------------
/docker-image/etc/fluent-bit.conf:
--------------------------------------------------------------------------------
 1 | [SERVICE]
 2 |     Flush          1
 3 |     Daemon         Off
 4 |     Log_Level      info
 5 |     Parsers_File   parsers.conf
 6 | 
 7 | [INPUT]
 8 |     Name           tail
 9 |     Tag            kube.*
10 |     Path           /var/log/containers/*.log
11 |     Parser         docker
12 |     DB             /var/log/flb_kube.db
13 |     Mem_Buf_Limit  5MB
14 | 
15 | [FILTER]
16 |     Name           kubernetes
17 |     Match          kube.*
18 |     Kube_URL       https://kubernetes.default.svc:443
19 |     Merge_JSON_Log On
20 | 
21 | [OUTPUT]
22 |     Name   sls
23 |     Match  *
24 | 


--------------------------------------------------------------------------------
/docker-image/etc/parsers.conf:
--------------------------------------------------------------------------------
 1 | [PARSER]
 2 |     Name   apache
 3 |     Format regex
 4 |     Regex  ^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*?)(?: +\S*)?)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$
 5 |     Time_Key time
 6 |     Time_Format %d/%b/%Y:%H:%M:%S %z
 7 | 
 8 | [PARSER]
 9 |     Name   apache2
10 |     Format regex
11 |     Regex  ^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$
12 |     Time_Key time
13 |     Time_Format %d/%b/%Y:%H:%M:%S %z
14 | 
15 | [PARSER]
16 |     Name   apache_error
17 |     Format regex
18 |     Regex  ^\[[^ ]* (?<time>[^\]]*)\] \[(?<level>[^\]]*)\](?: \[pid (?<pid>[^\]]*)\])?( \[client (?<client>[^\]]*)\])? (?<message>.*)$
19 | 
20 | [PARSER]
21 |     Name   nginx
22 |     Format regex
23 |     Regex ^(?<remote>[^ ]*) (?<host>[^ ]*) (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*?)(?: +\S*)?)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$
24 |     Time_Key time
25 |     Time_Format %d/%b/%Y:%H:%M:%S %z
26 | 
27 | [PARSER]
28 |     Name   json-test
29 |     Format json
30 |     Time_Key time
31 |     Time_Format %d/%b/%Y:%H:%M:%S %z
32 | 
33 | [PARSER]
34 |     Name        docker
35 |     Format      json
36 |     Time_Key    time
37 |     Time_Format %Y-%m-%dT%H:%M:%S.%L
38 |     Time_Keep   On
39 | 
40 | [PARSER]
41 |     Name        syslog
42 |     Format      regex
43 |     Regex       ^\<(?<pri>[0-9]+)\>(?<time>[^ ]* {1,2}[^ ]* [^ ]*) (?<host>[^ ]*) (?<ident>[a-zA-Z0-9_\/\.\-]*)(?:\[(?<pid>[0-9]+)\])?(?:[^\:]*\:)? *(?<message>.*)$
44 |     Time_Key    time
45 |     Time_Format %b %d %H:%M:%S
46 | 


--------------------------------------------------------------------------------
/flatten.go:
--------------------------------------------------------------------------------
  1 | // Flatten makes flat, one-dimensional maps from arbitrarily nested ones.
  2 | //
  3 | // Map keys turn into compound
  4 | // names, like `a.b.1.c` (dotted style) or `a[b][1][c]` (Rails style).  It takes input as either JSON strings or
  5 | // Go structures.  It (only) knows how to traverse JSON types: maps, slices and scalars.
  6 | //
  7 | // You can flatten JSON strings.
  8 | //
  9 | //	nested := `{
 10 | //	  "one": {
 11 | //	    "two": [
 12 | //	      "2a",
 13 | //	      "2b"
 14 | //	    ]
 15 | //	  },
 16 | //	  "side": "value"
 17 | //	}`
 18 | //
 19 | //	flat, err := FlattenString(nested, "", DotStyle)
 20 | //
 21 | //	// output: `{ "one.two.0": "2a", "one.two.1": "2b", "side": "value" }`
 22 | //
 23 | // Or Go maps directly.
 24 | //
 25 | //	t := map[string]interface{}{
 26 | //		"a": "b",
 27 | //		"c": map[string]interface{}{
 28 | //			"d": "e",
 29 | //			"f": "g",
 30 | //		},
 31 | //		"z": 1.4567,
 32 | //	}
 33 | //
 34 | //	flat, err := Flatten(nested, "", RailsStyle)
 35 | //
 36 | //	// output:
 37 | //	// map[string]interface{}{
 38 | //	//	"a":    "b",
 39 | //	//	"c[d]": "e",
 40 | //	//	"c[f]": "g",
 41 | //	//	"z":    1.4567,
 42 | //	// }
 43 | //
 44 | package main
 45 | 
 46 | import (
 47 | 	"errors"
 48 | 	"strconv"
 49 | )
 50 | 
 51 | // The presentation style of keys.
 52 | type SeparatorStyle int
 53 | 
 54 | const (
 55 | 	_ SeparatorStyle = iota
 56 | 
 57 | 	// Separate nested key components with dots, e.g. "a.b.1.c.d"
 58 | 	DotStyle
 59 | 
 60 | 	// Separate ala Rails, e.g. "a[b][c][1][d]"
 61 | 	RailsStyle
 62 | 
 63 | 	// Separate with underscore, e.g. "a_b_1_c_d"
 64 | 	UnderscoreStyle
 65 | )
 66 | 
 67 | // Nested input must be a map or slice
 68 | var NotValidInputError = errors.New("Not a valid input: map or slice")
 69 | 
 70 | // Flatten generates a flat map from a nested one.  The original may include values of type map, slice and scalar,
 71 | // but not struct.  Keys in the flat map will be a compound of descending map keys and slice iterations.
 72 | // The presentation of keys is set by style.  A prefix is joined to each key.
 73 | func Flatten(nested map[interface{}]interface{}, prefix string, style SeparatorStyle) (map[string]interface{}, error) {
 74 | 	flatmap := make(map[string]interface{})
 75 | 
 76 | 	err := flatten(true, flatmap, nested, prefix, style)
 77 | 	if err != nil {
 78 | 		return nil, err
 79 | 	}
 80 | 
 81 | 	return flatmap, nil
 82 | }
 83 | 
 84 | func flatten(top bool, flatMap map[string]interface{}, nested interface{}, prefix string, style SeparatorStyle) error {
 85 | 	assign := func(newKey string, v interface{}) error {
 86 | 		switch v.(type) {
 87 | 		case map[interface{}]interface{}, []interface{}:
 88 | 			if err := flatten(false, flatMap, v, newKey, style); err != nil {
 89 | 				return err
 90 | 			}
 91 | 		default:
 92 | 			flatMap[newKey] = v
 93 | 		}
 94 | 
 95 | 		return nil
 96 | 	}
 97 | 
 98 | 	switch nested.(type) {
 99 | 	case map[interface{}]interface{}:
100 | 		for k, v := range nested.(map[interface{}]interface{}) {
101 | 			newKey := enkey(top, prefix, k.(string), style)
102 | 			assign(newKey, v)
103 | 		}
104 | 	case []interface{}:
105 | 		for i, v := range nested.([]interface{}) {
106 | 			newKey := enkey(top, prefix, strconv.Itoa(i), style)
107 | 			assign(newKey, v)
108 | 		}
109 | 	default:
110 | 		return NotValidInputError
111 | 	}
112 | 
113 | 	return nil
114 | }
115 | 
116 | func enkey(top bool, prefix, subkey string, style SeparatorStyle) string {
117 | 	key := prefix
118 | 
119 | 	if top {
120 | 		key += subkey
121 | 	} else {
122 | 		switch style {
123 | 		case DotStyle:
124 | 			key += "." + subkey
125 | 		case RailsStyle:
126 | 			key += "[" + subkey + "]"
127 | 		case UnderscoreStyle:
128 | 			key += "_" + subkey
129 | 		}
130 | 	}
131 | 
132 | 	return key
133 | }
134 | 


--------------------------------------------------------------------------------
/fluent-bit-daemonset.yaml:
--------------------------------------------------------------------------------
 1 | apiVersion: extensions/v1beta1
 2 | kind: DaemonSet
 3 | metadata:
 4 |   name: fluent-bit
 5 |   namespace: kube-system
 6 |   labels:
 7 |     k8s-app: fluent-bit-logging
 8 |     version: v1
 9 |     kubernetes.io/cluster-service: "true"
10 | spec:
11 |   template:
12 |     metadata:
13 |       labels:
14 |         k8s-app: fluent-bit-logging
15 |         version: v1
16 |         kubernetes.io/cluster-service: "true"
17 |     spec:
18 |       containers:
19 |       - name: fluent-bit
20 |         image: kubeup/fluent-bit-aliyun:v0.1.0
21 |         imagePullPolicy: Always
22 |         env:
23 |           - name:  ALIYUN_ACCESS_KEY
24 |             valueFrom:
25 |               secretKeyRef:
26 |                 name: fluent-bit-config
27 |                 key: ALIYUN_ACCESS_KEY
28 |           - name:  ALIYUN_ACCESS_KEY_SECRET
29 |             valueFrom:
30 |               secretKeyRef:
31 |                 name: fluent-bit-config
32 |                 key: ALIYUN_ACCESS_KEY_SECRET
33 |           - name:  ALIYUN_SLS_PROJECT
34 |             valueFrom:
35 |               secretKeyRef:
36 |                 name: fluent-bit-config
37 |                 key: ALIYUN_SLS_PROJECT
38 |           - name:  ALIYUN_SLS_LOGSTORE
39 |             valueFrom:
40 |               secretKeyRef:
41 |                 name: fluent-bit-config
42 |                 key: ALIYUN_SLS_LOGSTORE
43 |           - name:  ALIYUN_SLS_ENDPOINT
44 |             valueFrom:
45 |               secretKeyRef:
46 |                 name: fluent-bit-config
47 |                 key: ALIYUN_SLS_ENDPOINT
48 |         resources:
49 |           limits:
50 |             memory: 100Mi
51 |           requests:
52 |             cpu: 100m
53 |             memory: 100Mi
54 |         volumeMounts:
55 |         - name: varlog
56 |           mountPath: /var/log
57 |         - name: varlibdockercontainers
58 |           mountPath: /var/lib/docker/containers
59 |           readOnly: true
60 |       terminationGracePeriodSeconds: 10
61 |       volumes:
62 |       - name: varlog
63 |         hostPath:
64 |           path: /var/log
65 |       - name: varlibdockercontainers
66 |         hostPath:
67 |           path: /var/lib/docker/containers
68 | 


--------------------------------------------------------------------------------
/glide.lock:
--------------------------------------------------------------------------------
 1 | hash: c2d36aa602f1f36b9a3826812def7406b71aafc620fd37a834022620d3874a81
 2 | updated: 2017-06-05T16:36:23.570557474+08:00
 3 | imports:
 4 | - name: github.com/cloudflare/golz4
 5 |   version: ef862a3cdc58a6f1fee4e3af3d44fbe279194cde
 6 | - name: github.com/fluent/fluent-bit-go
 7 |   version: 7c5a0b221303e9e75d0ea7cb23416c8d14e48d0b
 8 |   subpackages:
 9 |   - output
10 | - name: github.com/galaxydi/go-loghub
11 |   version: 228ca31911b37dd900a5ab9a3fbdc66c2d88ab16
12 | - name: github.com/gogo/protobuf
13 |   version: c0656edd0d9eab7c66d1eb0c568f9039345796f7
14 |   subpackages:
15 |   - proto
16 | - name: github.com/golang/glog
17 |   version: 44145f04b68cf362d9c4df2182967c2275eaefed
18 | - name: github.com/ugorji/go
19 |   version: ded73eae5db7e7a0ef6f55aace87a2873c5d2b74
20 |   subpackages:
21 |   - codec
22 | testImports: []
23 | 


--------------------------------------------------------------------------------
/glide.yaml:
--------------------------------------------------------------------------------
 1 | package: github.com/kubeup/fluent-bit-aliyun
 2 | ignore:
 3 | - net/url
 4 | - net/rpc
 5 | - net/http
 6 | import:
 7 | - package: github.com/fluent/fluent-bit-go
 8 |   subpackages:
 9 |   - output
10 | - package: github.com/galaxydi/go-loghub
11 | - package: github.com/gogo/protobuf
12 |   subpackages:
13 |   - proto
14 | - package: github.com/ugorji/go
15 |   subpackages:
16 |   - codec
17 | 


--------------------------------------------------------------------------------
/out_sls.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"C"
  5 | 	"fmt"
  6 | 	"os"
  7 | 	"reflect"
  8 | 	"unsafe"
  9 | 
 10 | 	"github.com/fluent/fluent-bit-go/output"
 11 | 	sls "github.com/galaxydi/go-loghub"
 12 | 	"github.com/gogo/protobuf/proto"
 13 | 	"github.com/ugorji/go/codec"
 14 | )
 15 | 
 16 | var project *sls.LogProject
 17 | var logstore *sls.LogStore
 18 | 
 19 | //export FLBPluginInit
 20 | func FLBPluginInit(ctx unsafe.Pointer) int {
 21 | 	return FLBPluginRegister(ctx)
 22 | }
 23 | 
 24 | //export FLBPluginRegister
 25 | func FLBPluginRegister(ctx unsafe.Pointer) int {
 26 | 	accessKey := os.Getenv("ALIYUN_ACCESS_KEY")
 27 | 	accessKeySecret := os.Getenv("ALIYUN_ACCESS_KEY_SECRET")
 28 | 	projectName := os.Getenv("ALIYUN_SLS_PROJECT")
 29 | 	endpoint := os.Getenv("ALIYUN_SLS_ENDPOINT")
 30 | 	logstoreName := os.Getenv("ALIYUN_SLS_LOGSTORE")
 31 | 
 32 | 	project = &sls.LogProject{
 33 | 		Name:            projectName,
 34 | 		Endpoint:        endpoint,
 35 | 		AccessKeyID:     accessKey,
 36 | 		AccessKeySecret: accessKeySecret,
 37 | 	}
 38 | 
 39 | 	var err error
 40 | 	logstore, err = project.GetLogStore(logstoreName)
 41 | 	if err != nil {
 42 | 		fmt.Printf("Unable to get logstore %v: %v", logstoreName, err)
 43 | 		return output.FLB_ERROR
 44 | 	}
 45 | 	return output.FLBPluginRegister(ctx, "sls", "Aliyun SLS output")
 46 | }
 47 | 
 48 | //export FLBPluginFlush
 49 | func FLBPluginFlush(data unsafe.Pointer, length C.int, tag *C.char) int {
 50 | 	var h codec.Handle = new(codec.MsgpackHandle)
 51 | 	var b []byte
 52 | 	var m interface{}
 53 | 	var err error
 54 | 
 55 | 	if logstore == nil {
 56 | 		fmt.Printf("logstore is nil")
 57 | 		return output.FLB_ERROR
 58 | 	}
 59 | 
 60 | 	b = C.GoBytes(data, length)
 61 | 	dec := codec.NewDecoderBytes(b, h)
 62 | 
 63 | 	// Iterate the original MessagePack array
 64 | 	logs := []*sls.Log{}
 65 | 	for {
 66 | 		// Decode the entry
 67 | 		err = dec.Decode(&m)
 68 | 		if err != nil {
 69 | 			break
 70 | 		}
 71 | 
 72 | 		// Get a slice and their two entries: timestamp and map
 73 | 		slice := reflect.ValueOf(m)
 74 | 		timestampData := slice.Index(0)
 75 | 		data := slice.Index(1)
 76 | 		timestamp, ok := timestampData.Interface().(uint64)
 77 | 		if !ok {
 78 | 			fmt.Printf("Unable to convert timestamp: %+v", timestampData)
 79 | 			return output.FLB_ERROR
 80 | 		}
 81 | 
 82 | 		// Convert slice data to a real map and iterate
 83 | 		mapData := data.Interface().(map[interface{}]interface{})
 84 | 		flattenData, err := Flatten(mapData, "", UnderscoreStyle)
 85 | 		if err != nil {
 86 | 			break
 87 | 		}
 88 | 		content := []*sls.LogContent{}
 89 | 		for k, v := range flattenData {
 90 | 			value := ""
 91 | 			switch t := v.(type) {
 92 | 			case string:
 93 | 				value = t
 94 | 			case []byte:
 95 | 				value = string(t)
 96 | 			default:
 97 | 				value = fmt.Sprintf("%v", v)
 98 | 			}
 99 | 			content = append(content, &sls.LogContent{
100 | 				Key:   proto.String(k),
101 | 				Value: proto.String(value),
102 | 			})
103 | 		}
104 | 		log := &sls.Log{
105 | 			Time:     proto.Uint32(uint32(timestamp)),
106 | 			Contents: content,
107 | 		}
108 | 		logs = append(logs, log)
109 | 	}
110 | 	loggroup := &sls.LogGroup{
111 | 		Topic:  proto.String(C.GoString(tag)),
112 | 		Source: proto.String(""),
113 | 		Logs:   logs,
114 | 	}
115 | 	err = logstore.PutLogs(loggroup)
116 | 	if err != nil {
117 | 		return output.FLB_ERROR
118 | 	}
119 | 
120 | 	// Return options:
121 | 	//
122 | 	// output.FLB_OK    = data have been processed.
123 | 	// output.FLB_ERROR = unrecoverable error, do not try this again.
124 | 	// output.FLB_RETRY = retry to flush later.
125 | 	return output.FLB_OK
126 | }
127 | 
128 | //export FLBPluginExit
129 | func FLBPluginExit() int {
130 | 	return 0
131 | }
132 | 
133 | func main() {
134 | }
135 | 


--------------------------------------------------------------------------------