Golang Route.AdapterTransport 예제들

예제 #1

파일: raw.go 프로젝트: gswallow/logspout

func NewRawAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		transport, found = router.AdapterTransports.Lookup(route.AdapterTransport("unix"))
		if !found {
			return nil, errors.New("bad transport: " + route.Adapter)
		}
	}
	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}
	tmplStr := "{{.Data}}\n"
	if os.Getenv("RAW_FORMAT") != "" {
		tmplStr = os.Getenv("RAW_FORMAT")
	}
	tmpl, err := template.New("raw").Parse(tmplStr)
	if err != nil {
		return nil, err
	}
	return &RawAdapter{
		route: route,
		conn:  conn,
		tmpl:  tmpl,
	}, nil
}

예제 #2

파일: raw.go 프로젝트: Dataman-Cloud/logspout

func NewRawAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("bad transport: " + route.Adapter)
	}
	address = route.Address
	netType = strings.Replace(route.Adapter, "raw+", "", -1)
	conn, err := transport.Dial(route.Address, route.Options)
	connection = conn
	if err != nil {
		return nil, err
	}
	tmplStr := "{{.Data}}\n"
	if os.Getenv("RAW_FORMAT") != "" {
		tmplStr = os.Getenv("RAW_FORMAT")
	}
	tmpl, err := template.New("raw").Parse(tmplStr)
	if err != nil {
		return nil, err
	}
	go connPing()
	return &RawAdapter{
		route: route,
		conn:  conn,
		tmpl:  tmpl,
	}, nil
}

예제 #3

파일: syslog.go 프로젝트: dkiser/logspout-syslog-json

func NewSyslogAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("bad transport: " + route.Adapter)
	}
	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}

	format := getopt("SYSLOG_FORMAT", "rfc5424")
	priority := getopt("SYSLOG_PRIORITY", "{{.Priority}}")
	hostname := getopt("SYSLOG_HOSTNAME", "{{.Container.Config.Hostname}}")
	pid := getopt("SYSLOG_PID", "{{.Container.State.Pid}}")
	tag := getopt("SYSLOG_TAG", "{{.ContainerName}}"+route.Options["append_tag"])
	structuredData := getopt("SYSLOG_STRUCTURED_DATA", "")
	if route.Options["structured_data"] != "" {
		structuredData = route.Options["structured_data"]
	}
	data := getopt("SYSLOG_DATA", "{{.Data}}")
	json := getoptexists("SYSLOG_JSON")

	if structuredData == "" {
		structuredData = "-"
	} else {
		structuredData = fmt.Sprintf("[%s]", structuredData)
	}

	var tmplStr string
	switch format {
	case "rfc5424":
		tmplStr = fmt.Sprintf("<%s>1 {{.Timestamp}} %s %s %s - %s %s\n",
			priority, hostname, tag, pid, structuredData, data)
	case "rfc3164":
		tmplStr = fmt.Sprintf("<%s>{{.Timestamp}} %s %s[%s]: %s\n",
			priority, hostname, tag, pid, data)
	default:
		return nil, errors.New("unsupported syslog format: " + format)
	}
	tmpl, err := template.New("syslog").Parse(tmplStr)
	if err != nil {
		return nil, err
	}
	return &SyslogAdapter{
		route:     route,
		conn:      conn,
		tmpl:      tmpl,
		transport: transport,
		json:      json,
	}, nil
}

예제 #4

파일: adapter.go 프로젝트: krancour/logspout-v3-deis

func newDeisLogAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("deis-udp"))
	if !found {
		return nil, errors.New("bad transport: " + route.Adapter)
	}
	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}
	return &deisLogAdapter{
		route: route,
		conn:  conn,
	}, nil
}

예제 #5

파일: logstash.go 프로젝트: discourse/logspout-logstash

// NewLogstashAdapter creates a LogstashAdapter with UDP as the default transport.
func NewLogstashAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("unable to find adapter: " + route.Adapter)
	}

	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}

	return &LogstashAdapter{
		route: route,
		conn:  conn,
	}, nil
}

예제 #6

파일: logspout.go 프로젝트: AntiPaste/logspout-fluentd

// NewFluentdAdapter creates a Logspout fluentd adapter instance.
func NewFluentdAdapter(route *router.Route) (router.LogAdapter, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("tcp"))
	if !found {
		return nil, errors.New("bad transport: " + route.Adapter)
	}

	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}

	return &FluentdAdapter{
		conn:      conn,
		route:     route,
		transport: transport,
	}, nil
}

예제 #7

파일: logstash.go 프로젝트: keis/logspout-logstash

func connect(route *router.Route) (net.Conn, error) {
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("unable to find adapter: " + route.Adapter)
	}

	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}

	if reflect.TypeOf(conn).String() == "*net.TCPConn" {
		tcpconn := conn.(*net.TCPConn)
		err = tcpconn.SetKeepAlive(true)
		if err != nil {
			return nil, err
		}
	}

	return conn, nil
}

예제 #8

파일: cloudwatchlogs.go 프로젝트: nickschuch/logspout-cloudwatchlogs

func NewCloudWatchLogsAdapter(route *router.Route) (router.LogAdapter, error) {
	// Connect this adapter.
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("Bad transport: " + route.Adapter)
	}
	conn, err := transport.Dial(route.Address, route.Options)
	if err != nil {
		return nil, err
	}

	// Build out what the logs template should look like.
	tmpl, err := template.New("cloudwatchlogs").Parse("{{.Data}}\n")
	if err != nil {
		return nil, err
	}
	return &CloudWatchLogsAdapter{
		route: route,
		conn:  conn,
		tmpl:  tmpl,
	}, nil
}

예제 #9

파일: kafkaraw.go 프로젝트: Dataman-Cloud/logspout

func NewKafkaRawAdapter(route *router.Route) (router.LogAdapter, error) {
	topic = os.Getenv("TOPIC")
	compressType := os.Getenv("COMPRESS_TYPE")
	if topic == "" {
		err := errors.New("not found kafka topic")
		return nil, err
	}
	transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
	if !found {
		return nil, errors.New("bad transport: " + route.Adapter)
	}
	_ = transport
	config := kafka.NewConfig()
	if compressType == "gzip" {
		config.Producer.Compression = kafka.CompressionGZIP
	} else if compressType == "snappy" {
		config.Producer.Compression = kafka.CompressionSnappy
	} else {
		config.Producer.Compression = kafka.CompressionNone
	}
	producer, err := kafka.NewSyncProducer([]string{route.Address}, config)
	if err != nil {
		return nil, err
	}
	tmplStr := "{{.Data}}\n"
	if os.Getenv("RAW_FORMAT") != "" {
		tmplStr = os.Getenv("RAW_FORMAT")
	}
	tmpl, err := template.New("raw").Parse(tmplStr)
	if err != nil {
		return nil, err
	}
	return &RawAdapter{
		route:    route,
		producer: producer,
		tmpl:     tmpl,
	}, nil
}