From 75a1d9357a8268ffb447a245388d906073ee7836 Mon Sep 17 00:00:00 2001 From: Pavol Loffay Date: Fri, 15 May 2020 14:22:46 +0200 Subject: [PATCH] Configure Jaeger receiver and exporter by flags (#2241) * Configure Jaeger receiver and exporter by flags Signed-off-by: Pavol Loffay * Add config tests Signed-off-by: Pavol Loffay * Refactor flags Signed-off-by: Pavol Loffay * improve test coverage Signed-off-by: Pavol Loffay * make scoped test Signed-off-by: Pavol Loffay * Fix lint Signed-off-by: Pavol Loffay * Move sampling to agent in test Signed-off-by: Pavol Loffay * Use host port Signed-off-by: Pavol Loffay * Order Signed-off-by: Pavol Loffay * Add comment Signed-off-by: Pavol Loffay * Bind to all ports Signed-off-by: Pavol Loffay --- cmd/agent/app/flags.go | 12 +- cmd/agent/app/reporter/grpc/flags.go | 7 +- cmd/collector/app/builder_flags.go | 35 ++-- .../app/defaults/default_config.go | 31 ++-- .../app/defaults/default_config_test.go | 168 +++++++++++++++++- .../app/exporter/jaegerexporter/.nocover | 1 - .../jaegerexporter/jaeger_exporter.go | 12 +- .../jaegerexporter/jaeger_exporter_test.go | 101 +++++++++++ .../jaegerexporter/testdata/config.yaml | 16 ++ .../app/{util.go => flags.go} | 15 +- .../app/processor/resourceprocessor/flags.go | 28 +++ .../resourceprocessor/resource_processor.go | 9 - .../app/receiver/jaegerreceiver/flags.go | 41 +++++ .../jaegerreceiver/jaeger_receiver.go | 70 +++++++- .../jaegerreceiver/jaeger_receiver_test.go | 123 +++++++++++-- cmd/opentelemetry-collector/cmd/agent/main.go | 9 +- .../cmd/collector/main.go | 11 +- .../cmd/ingester/main.go | 6 +- cmd/opentelemetry-collector/go.mod | 2 +- cmd/opentelemetry-collector/go.sum | 4 + crossdock/jaeger-docker-compose.yml | 2 +- .../jaeger-opentelemetry-docker-compose.yml | 2 +- .../sampling/strategystore/static/options.go | 7 +- 23 files changed, 623 insertions(+), 89 deletions(-) delete mode 100644 cmd/opentelemetry-collector/app/exporter/jaegerexporter/.nocover create mode 100644 cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter_test.go create mode 100644 cmd/opentelemetry-collector/app/exporter/jaegerexporter/testdata/config.yaml rename cmd/opentelemetry-collector/app/{util.go => flags.go} (71%) create mode 100644 cmd/opentelemetry-collector/app/processor/resourceprocessor/flags.go create mode 100644 cmd/opentelemetry-collector/app/receiver/jaegerreceiver/flags.go diff --git a/cmd/agent/app/flags.go b/cmd/agent/app/flags.go index 34bb80d2598..7032d79873c 100644 --- a/cmd/agent/app/flags.go +++ b/cmd/agent/app/flags.go @@ -30,7 +30,8 @@ const ( suffixServerQueueSize = "server-queue-size" suffixServerMaxPacketSize = "server-max-packet-size" suffixServerHostPort = "server-host-port" - httpServerHostPort = "http-server.host-port" + // HTTPServerHostPort is the flag for HTTP endpoint + HTTPServerHostPort = "http-server.host-port" ) var defaultProcessors = []struct { @@ -52,8 +53,13 @@ func AddFlags(flags *flag.FlagSet) { flags.Int(prefix+suffixServerMaxPacketSize, defaultMaxPacketSize, "max packet size for the UDP server") flags.String(prefix+suffixServerHostPort, ":"+strconv.Itoa(p.port), "host:port for the UDP server") } + AddOTELFlags(flags) +} + +// AddOTELFlags adds flags that are exposed by OTEL collector +func AddOTELFlags(flags *flag.FlagSet) { flags.String( - httpServerHostPort, + HTTPServerHostPort, defaultHTTPServerHostPort, "host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint)") } @@ -70,7 +76,7 @@ func (b *Builder) InitFromViper(v *viper.Viper) *Builder { b.Processors = append(b.Processors, *p) } - b.HTTPServer.HostPort = portNumToHostPort(v.GetString(httpServerHostPort)) + b.HTTPServer.HostPort = portNumToHostPort(v.GetString(HTTPServerHostPort)) return b } diff --git a/cmd/agent/app/reporter/grpc/flags.go b/cmd/agent/app/reporter/grpc/flags.go index e557a8be6fb..43c25502b82 100644 --- a/cmd/agent/app/reporter/grpc/flags.go +++ b/cmd/agent/app/reporter/grpc/flags.go @@ -39,9 +39,14 @@ var tlsFlagsConfig = tlscfg.ClientFlagsConfig{ // AddFlags adds flags for Options. func AddFlags(flags *flag.FlagSet) { - flags.String(collectorHostPort, "", "Comma-separated string representing host:port of a static list of collectors to connect to directly") flags.Uint(retry, defaultMaxRetry, "Sets the maximum number of retries for a call") flags.Int(discoveryMinPeers, 3, "Max number of collectors to which the agent will try to connect at any given time") + AddOTELFlags(flags) +} + +// AddOTELFlags adds flags that are exposed by OTEL collector +func AddOTELFlags(flags *flag.FlagSet) { + flags.String(collectorHostPort, "", "Comma-separated string representing host:port of a static list of collectors to connect to directly") tlsFlagsConfig.AddFlags(flags) } diff --git a/cmd/collector/app/builder_flags.go b/cmd/collector/app/builder_flags.go index 06f2768e67e..1c989c4f544 100644 --- a/cmd/collector/app/builder_flags.go +++ b/cmd/collector/app/builder_flags.go @@ -27,13 +27,15 @@ import ( ) const ( - collectorDynQueueSizeMemory = "collector.queue-size-memory" - collectorQueueSize = "collector.queue-size" - collectorNumWorkers = "collector.num-workers" - collectorHTTPPort = "collector.http-port" - collectorGRPCPort = "collector.grpc-port" - collectorHTTPHostPort = "collector.http-server.host-port" - collectorGRPCHostPort = "collector.grpc-server.host-port" + collectorDynQueueSizeMemory = "collector.queue-size-memory" + collectorQueueSize = "collector.queue-size" + collectorNumWorkers = "collector.num-workers" + collectorHTTPPort = "collector.http-port" + collectorGRPCPort = "collector.grpc-port" + // CollectorHTTPHostPort is the flag for collector HTTP port + CollectorHTTPHostPort = "collector.http-server.host-port" + // CollectorGRPCHostPort is the flag for collector gRPC port + CollectorGRPCHostPort = "collector.grpc-server.host-port" collectorZipkinHTTPPort = "collector.zipkin.http-port" collectorZipkinHTTPHostPort = "collector.zipkin.host-port" collectorTags = "collector.tags" @@ -79,16 +81,21 @@ type CollectorOptions struct { func AddFlags(flags *flag.FlagSet) { flags.Int(collectorQueueSize, DefaultQueueSize, "The queue size of the collector") flags.Int(collectorNumWorkers, DefaultNumWorkers, "The number of workers pulling items from the queue") - flags.Int(collectorHTTPPort, 0, collectorHTTPPortWarning+" see --"+collectorHTTPHostPort) - flags.Int(collectorGRPCPort, 0, collectorGRPCPortWarning+" see --"+collectorGRPCHostPort) + flags.Int(collectorHTTPPort, 0, collectorHTTPPortWarning+" see --"+CollectorHTTPHostPort) + flags.Int(collectorGRPCPort, 0, collectorGRPCPortWarning+" see --"+CollectorGRPCHostPort) flags.Int(collectorZipkinHTTPPort, 0, collectorZipkinHTTPPortWarning+" see --"+collectorZipkinHTTPHostPort) - flags.String(collectorHTTPHostPort, ports.PortToHostPort(ports.CollectorHTTP), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's HTTP server") - flags.String(collectorGRPCHostPort, ports.PortToHostPort(ports.CollectorGRPC), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's GRPC server") - flags.String(collectorZipkinHTTPHostPort, ports.PortToHostPort(0), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's Zipkin server") flags.Uint(collectorDynQueueSizeMemory, 0, "(experimental) The max memory size in MiB to use for the dynamic queue.") flags.String(collectorTags, "", "One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue}") flags.String(collectorZipkinAllowedOrigins, "*", "Comma separated list of allowed origins for the Zipkin collector service, default accepts all") flags.String(collectorZipkinAllowedHeaders, "content-type", "Comma separated list of allowed headers for the Zipkin collector service, default content-type") + AddOTELFlags(flags) +} + +// AddOTELFlags adds flags that are exposed by OTEL collector +func AddOTELFlags(flags *flag.FlagSet) { + flags.String(collectorZipkinHTTPHostPort, ports.PortToHostPort(0), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's Zipkin server") + flags.String(CollectorHTTPHostPort, ports.PortToHostPort(ports.CollectorHTTP), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's HTTP server") + flags.String(CollectorGRPCHostPort, ports.PortToHostPort(ports.CollectorGRPC), "The host:port (e.g. 127.0.0.1:5555 or :5555) of the collector's GRPC server") tlsFlagsConfig.AddFlags(flags) } @@ -97,8 +104,8 @@ func (cOpts *CollectorOptions) InitFromViper(v *viper.Viper) *CollectorOptions { cOpts.DynQueueSizeMemory = v.GetUint(collectorDynQueueSizeMemory) * 1024 * 1024 // we receive in MiB and store in bytes cOpts.QueueSize = v.GetInt(collectorQueueSize) cOpts.NumWorkers = v.GetInt(collectorNumWorkers) - cOpts.CollectorHTTPHostPort = getAddressFromCLIOptions(v.GetInt(collectorHTTPPort), v.GetString(collectorHTTPHostPort)) - cOpts.CollectorGRPCHostPort = getAddressFromCLIOptions(v.GetInt(collectorGRPCPort), v.GetString(collectorGRPCHostPort)) + cOpts.CollectorHTTPHostPort = getAddressFromCLIOptions(v.GetInt(collectorHTTPPort), v.GetString(CollectorHTTPHostPort)) + cOpts.CollectorGRPCHostPort = getAddressFromCLIOptions(v.GetInt(collectorGRPCPort), v.GetString(CollectorGRPCHostPort)) cOpts.CollectorZipkinHTTPHostPort = getAddressFromCLIOptions(v.GetInt(collectorZipkinHTTPPort), v.GetString(collectorZipkinHTTPHostPort)) cOpts.CollectorTags = flags.ParseJaegerTags(v.GetString(collectorTags)) cOpts.CollectorZipkinAllowedOrigins = v.GetString(collectorZipkinAllowedOrigins) diff --git a/cmd/opentelemetry-collector/app/defaults/default_config.go b/cmd/opentelemetry-collector/app/defaults/default_config.go index 4092f75244e..6ede8202b40 100644 --- a/cmd/opentelemetry-collector/app/defaults/default_config.go +++ b/cmd/opentelemetry-collector/app/defaults/default_config.go @@ -76,19 +76,24 @@ func CollectorConfig(storageType string, zipkinHostPort string, factories config func createCollectorReceivers(zipkinHostPort string, factories config.Factories) configmodels.Receivers { jaeger := factories.Receivers["jaeger"].CreateDefaultConfig().(*jaegerreceiver.Config) - // TODO load and serve sampling strategies - // TODO bind sampling strategies file - jaeger.Protocols = map[string]*receiver.SecureReceiverSettings{ - "grpc": { + if jaeger.Protocols == nil { + jaeger.Protocols = map[string]*receiver.SecureReceiverSettings{} + } + // The CreateDefaultConfig is enabling protocols from flags + // we do not want to override it here + if _, ok := jaeger.Protocols["grpc"]; !ok { + jaeger.Protocols["grpc"] = &receiver.SecureReceiverSettings{ ReceiverSettings: configmodels.ReceiverSettings{ Endpoint: gRPCEndpoint, }, - }, - "thrift_http": { + } + } + if _, ok := jaeger.Protocols["thrift_http"]; !ok { + jaeger.Protocols["thrift_http"] = &receiver.SecureReceiverSettings{ ReceiverSettings: configmodels.ReceiverSettings{ Endpoint: httpThriftBinaryEndpoint, }, - }, + } } recvs := map[string]configmodels.Receiver{ "jaeger": jaeger, @@ -159,17 +164,19 @@ func AgentConfig(factories config.Factories) *configmodels.Config { func createAgentReceivers(factories config.Factories) configmodels.Receivers { jaeger := factories.Receivers["jaeger"].CreateDefaultConfig().(*jaegerreceiver.Config) - jaeger.Protocols = map[string]*receiver.SecureReceiverSettings{ - "thrift_compact": { + if _, ok := jaeger.Protocols["thrift_compact"]; !ok { + jaeger.Protocols["thrift_compact"] = &receiver.SecureReceiverSettings{ ReceiverSettings: configmodels.ReceiverSettings{ Endpoint: udpThriftCompactEndpoint, }, - }, - "thrift_binary": { + } + } + if _, ok := jaeger.Protocols["thrift_binary"]; !ok { + jaeger.Protocols["thrift_binary"] = &receiver.SecureReceiverSettings{ ReceiverSettings: configmodels.ReceiverSettings{ Endpoint: udpThriftBinaryEndpoint, }, - }, + } } recvs := configmodels.Receivers{ "jaeger": jaeger, diff --git a/cmd/opentelemetry-collector/app/defaults/default_config_test.go b/cmd/opentelemetry-collector/app/defaults/default_config_test.go index c9befea7b47..e8d51efb9c6 100644 --- a/cmd/opentelemetry-collector/app/defaults/default_config_test.go +++ b/cmd/opentelemetry-collector/app/defaults/default_config_test.go @@ -20,16 +20,19 @@ import ( "testing" "github.com/open-telemetry/opentelemetry-collector/config" + "github.com/open-telemetry/opentelemetry-collector/config/configgrpc" "github.com/open-telemetry/opentelemetry-collector/config/configmodels" "github.com/open-telemetry/opentelemetry-collector/exporter/jaegerexporter" "github.com/open-telemetry/opentelemetry-collector/processor/resourceprocessor" + "github.com/open-telemetry/opentelemetry-collector/receiver" "github.com/open-telemetry/opentelemetry-collector/receiver/jaegerreceiver" + "github.com/open-telemetry/opentelemetry-collector/receiver/zipkinreceiver" "github.com/spf13/viper" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/zap" - "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" + "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/cassandra" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/elasticsearch" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/grpcplugin" @@ -118,7 +121,7 @@ func TestDefaultCollectorConfig(t *testing.T) { } for _, test := range tests { t.Run(test.storageType, func(t *testing.T) { - v, _ := jConfig.Viperize(grpc.AddFlags) + v, _ := jConfig.Viperize(app.AddComponentFlags) factories := Components(v) for key, val := range test.config { v.Set(key, val) @@ -162,6 +165,87 @@ func TestDefaultCollectorConfig(t *testing.T) { } } +func TestCreateCollectorReceivers(t *testing.T) { + tests := []struct { + name string + args []string + zipkinHostPort string + receivers configmodels.Receivers + }{ + { + name: "defaultWithoutZipkin", + args: []string{}, + zipkinHostPort: ":0", + receivers: configmodels.Receivers{ + "jaeger": &jaegerreceiver.Config{ + TypeVal: "jaeger", + NameVal: "jaeger", + Protocols: map[string]*receiver.SecureReceiverSettings{ + "grpc": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: gRPCEndpoint, + }, + }, + "thrift_http": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: httpThriftBinaryEndpoint, + }, + }, + }, + }, + }, + }, + { + name: "configurationViaFlags", + args: []string{ + "--collector.grpc-server.host-port=host:11", + "--collector.grpc.tls.cert=cacert.crt", + "--collector.grpc.tls.key=keycert.crt", + "--collector.http-server.host-port=host2:22", + }, + zipkinHostPort: "localhost:55", + receivers: configmodels.Receivers{ + "jaeger": &jaegerreceiver.Config{ + TypeVal: "jaeger", + NameVal: "jaeger", + Protocols: map[string]*receiver.SecureReceiverSettings{ + "grpc": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: "host:11", + }, + TLSCredentials: &receiver.TLSCredentials{ + CertFile: "cacert.crt", + KeyFile: "keycert.crt", + }, + }, + "thrift_http": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: "host2:22", + }, + }, + }, + }, + "zipkin": &zipkinreceiver.Config{ + ReceiverSettings: configmodels.ReceiverSettings{ + NameVal: "zipkin", + TypeVal: "zipkin", + Endpoint: "localhost:55", + }, + }, + }, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + v, c := jConfig.Viperize(app.AddComponentFlags) + require.NoError(t, c.ParseFlags(test.args)) + factories := Components(v) + recvs := createCollectorReceivers(test.zipkinHostPort, factories) + assert.Equal(t, test.receivers, recvs) + }) + } +} + func TestDefaultAgentConfig(t *testing.T) { tests := []struct { config map[string]interface{} @@ -196,7 +280,7 @@ func TestDefaultAgentConfig(t *testing.T) { } for _, test := range tests { t.Run(fmt.Sprintf("%v", test.config), func(t *testing.T) { - v, _ := jConfig.Viperize(grpc.AddFlags) + v, _ := jConfig.Viperize(app.AddComponentFlags) for key, val := range test.config { v.Set(key, val) } @@ -221,6 +305,84 @@ func TestDefaultAgentConfig(t *testing.T) { } } +func TestCreateAgentReceivers(t *testing.T) { + tests := []struct { + args []string + receivers configmodels.Receivers + }{ + { + args: []string{""}, + receivers: configmodels.Receivers{ + "jaeger": &jaegerreceiver.Config{ + TypeVal: "jaeger", + NameVal: "jaeger", + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_compact": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: udpThriftCompactEndpoint, + }, + }, + "thrift_binary": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: udpThriftBinaryEndpoint, + }, + }, + }, + }, + }, + }, + { + args: []string{ + "--processor.jaeger-binary.server-host-port=host:1", + "--processor.jaeger-compact.server-host-port=host:2", + "--reporter.grpc.host-port=coll:33", + "--reporter.grpc.tls.enabled=true", + "--reporter.grpc.tls.ca=cacert.pem", + "--reporter.grpc.tls.cert=cert.pem", + "--reporter.grpc.tls.key=key.key", + }, + receivers: configmodels.Receivers{ + "jaeger": &jaegerreceiver.Config{ + TypeVal: "jaeger", + NameVal: "jaeger", + RemoteSampling: &jaegerreceiver.RemoteSamplingConfig{ + GRPCSettings: configgrpc.GRPCSettings{ + Endpoint: "coll:33", + TLSConfig: configgrpc.TLSConfig{ + UseSecure: true, + CaCert: "cacert.pem", + ClientCert: "cert.pem", + ClientKey: "key.key", + }, + }, + }, + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_binary": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: "host:1", + }, + }, + "thrift_compact": { + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: "host:2", + }, + }, + }, + }, + }, + }, + } + for _, test := range tests { + t.Run(fmt.Sprintf("%v", test.args), func(t *testing.T) { + v, c := jConfig.Viperize(app.AddComponentFlags) + require.NoError(t, c.ParseFlags(test.args)) + factories := Components(v) + recvs := createAgentReceivers(factories) + assert.Equal(t, test.receivers, recvs) + }) + } +} + func TestDefaultIngesterConfig(t *testing.T) { tests := []struct { storageType string diff --git a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/.nocover b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/.nocover deleted file mode 100644 index 9d6cf4b7fb6..00000000000 --- a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/.nocover +++ /dev/null @@ -1 +0,0 @@ -FIXME diff --git a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter.go b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter.go index e7a64e76c26..0b88f794e07 100644 --- a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter.go +++ b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter.go @@ -22,7 +22,7 @@ import ( "github.com/open-telemetry/opentelemetry-collector/exporter/jaegerexporter" "github.com/spf13/viper" - "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" + grpcRep "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" ) // Factory wraps jaegerexporter.Factory and makes the default config configurable via viper. @@ -44,15 +44,17 @@ func (f Factory) Type() configmodels.Type { // CreateDefaultConfig returns default configuration of Factory. // This function implements OTEL component.ExporterFactoryBase interface. func (f Factory) CreateDefaultConfig() configmodels.Exporter { - repCfg := grpc.ConnBuilder{} + repCfg := grpcRep.ConnBuilder{} repCfg.InitFromViper(f.Viper) cfg := f.Wrapped.CreateDefaultConfig().(*jaegerexporter.Config) if len(repCfg.CollectorHostPorts) > 0 { cfg.Endpoint = repCfg.CollectorHostPorts[0] } - cfg.GRPCSettings.UseSecure = repCfg.TLS.Enabled - cfg.GRPCSettings.CertPemFile = repCfg.TLS.CertPath - cfg.GRPCSettings.ServerNameOverride = repCfg.TLS.ServerName + cfg.GRPCSettings.TLSConfig.UseSecure = repCfg.TLS.Enabled + cfg.GRPCSettings.TLSConfig.CaCert = repCfg.TLS.CAPath + cfg.GRPCSettings.TLSConfig.ClientCert = repCfg.TLS.CertPath + cfg.GRPCSettings.TLSConfig.ClientKey = repCfg.TLS.KeyPath + cfg.GRPCSettings.TLSConfig.ServerNameOverride = repCfg.TLS.ServerName return cfg } diff --git a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter_test.go b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter_test.go new file mode 100644 index 00000000000..ab327d05ab6 --- /dev/null +++ b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/jaeger_exporter_test.go @@ -0,0 +1,101 @@ +// Copyright (c) 2020 The Jaeger Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package jaegerexporter + +import ( + "context" + "path" + "testing" + + "github.com/open-telemetry/opentelemetry-collector/component" + "github.com/open-telemetry/opentelemetry-collector/config" + "github.com/open-telemetry/opentelemetry-collector/config/configerror" + "github.com/open-telemetry/opentelemetry-collector/config/configmodels" + "github.com/open-telemetry/opentelemetry-collector/exporter/jaegerexporter" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/receiver/jaegerreceiver" + jConfig "github.com/jaegertracing/jaeger/pkg/config" +) + +func TestDefaultValues(t *testing.T) { + v, c := jConfig.Viperize(jaegerreceiver.AddFlags) + err := c.ParseFlags([]string{}) + require.NoError(t, err) + + factory := &Factory{Viper: v, Wrapped: &jaegerexporter.Factory{}} + cfg := factory.CreateDefaultConfig().(*jaegerexporter.Config) + assert.Empty(t, cfg.GRPCSettings.Endpoint) + tlsConf := cfg.TLSConfig + assert.False(t, tlsConf.UseSecure) + assert.Empty(t, tlsConf.CaCert) + assert.Empty(t, tlsConf.ClientKey) + assert.Empty(t, tlsConf.ClientCert) + assert.Empty(t, tlsConf.ServerNameOverride) +} + +func TestDefaultValueFromViper(t *testing.T) { + v, c := jConfig.Viperize(jaegerreceiver.AddFlags) + err := c.ParseFlags([]string{"--reporter.grpc.host-port=foo", "--reporter.grpc.tls.enabled=true", "--reporter.grpc.tls.ca=ca.crt"}) + require.NoError(t, err) + + f := &Factory{ + Wrapped: &jaegerexporter.Factory{}, + Viper: v, + } + + cfg := f.CreateDefaultConfig().(*jaegerexporter.Config) + assert.Equal(t, "foo", cfg.GRPCSettings.Endpoint) + tlsConfig := cfg.TLSConfig + assert.Equal(t, true, tlsConfig.UseSecure) + assert.Equal(t, "ca.crt", tlsConfig.CaCert) +} + +func TestLoadConfigAndFlags(t *testing.T) { + factories, err := config.ExampleComponents() + require.NoError(t, err) + + v, c := jConfig.Viperize(jaegerreceiver.AddFlags) + err = c.ParseFlags([]string{"--reporter.grpc.host-port=foo"}) + require.NoError(t, err) + + factory := &Factory{Viper: v, Wrapped: &jaegerexporter.Factory{}} + assert.Equal(t, "foo", factory.CreateDefaultConfig().(*jaegerexporter.Config).GRPCSettings.Endpoint) + + factories.Exporters["jaeger"] = factory + colConfig, err := config.LoadConfigFile(t, path.Join(".", "testdata", "config.yaml"), factories) + require.NoError(t, err) + require.NotNil(t, colConfig) + + cfg := colConfig.Exporters["jaeger"].(*jaegerexporter.Config) + assert.Equal(t, "bar", cfg.GRPCSettings.Endpoint) +} + +func TestType(t *testing.T) { + f := &Factory{ + Wrapped: &jaegerexporter.Factory{}, + } + assert.Equal(t, configmodels.Type("jaeger"), f.Type()) +} + +func TestCreateMetricsExporter(t *testing.T) { + f := &Factory{ + Wrapped: &jaegerexporter.Factory{}, + } + mReceiver, err := f.CreateMetricsExporter(context.Background(), component.ExporterCreateParams{}, nil) + assert.Equal(t, configerror.ErrDataTypeIsNotSupported, err) + assert.Nil(t, mReceiver) +} diff --git a/cmd/opentelemetry-collector/app/exporter/jaegerexporter/testdata/config.yaml b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/testdata/config.yaml new file mode 100644 index 00000000000..14f994fd098 --- /dev/null +++ b/cmd/opentelemetry-collector/app/exporter/jaegerexporter/testdata/config.yaml @@ -0,0 +1,16 @@ +receivers: + examplereceiver: + +processors: + exampleprocessor: + +exporters: + jaeger: + endpoint: bar + +service: + pipelines: + traces: + receivers: [examplereceiver] + processors: [exampleprocessor] + exporters: [jaeger] diff --git a/cmd/opentelemetry-collector/app/util.go b/cmd/opentelemetry-collector/app/flags.go similarity index 71% rename from cmd/opentelemetry-collector/app/util.go rename to cmd/opentelemetry-collector/app/flags.go index 65afa2592dc..e60dc078f02 100644 --- a/cmd/opentelemetry-collector/app/util.go +++ b/cmd/opentelemetry-collector/app/flags.go @@ -19,15 +19,26 @@ import ( "fmt" "strings" + jConfigFile "github.com/jaegertracing/jaeger/cmd/flags" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/cassandra" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/elasticsearch" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/grpcplugin" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/exporter/kafka" + "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/processor/resourceprocessor" + "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/receiver/jaegerreceiver" ) -// StorageFlags return a function that adds storage flags. +// AddComponentFlags adds all flags exposed by components +func AddComponentFlags(flags *flag.FlagSet) { + // Jaeger receiver (via sampling strategies receiver) exposes the same flags as exporter. + jaegerreceiver.AddFlags(flags) + resourceprocessor.AddFlags(flags) + jConfigFile.AddConfigFileFlag(flags) +} + +// AddStorageFlags return a function that adds storage flags. // storage parameter can contain a comma separated list of supported Jaeger storage backends. -func StorageFlags(storage string) (func(*flag.FlagSet), error) { +func AddStorageFlags(storage string) (func(*flag.FlagSet), error) { var flagFn []func(*flag.FlagSet) for _, s := range strings.Split(storage, ",") { switch s { diff --git a/cmd/opentelemetry-collector/app/processor/resourceprocessor/flags.go b/cmd/opentelemetry-collector/app/processor/resourceprocessor/flags.go new file mode 100644 index 00000000000..fd783f24cc9 --- /dev/null +++ b/cmd/opentelemetry-collector/app/processor/resourceprocessor/flags.go @@ -0,0 +1,28 @@ +// Copyright (c) 2020 The Jaeger Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package resourceprocessor + +import ( + "flag" + "fmt" + + "github.com/jaegertracing/jaeger/cmd/agent/app/reporter" +) + +// AddFlags adds flags for Options. +func AddFlags(flags *flag.FlagSet) { + flags.String(reporter.AgentTagsDeprecated, "", fmt.Sprintf("(deprecated, use --%s) One or more tags to be added to the Process tags of all spans passing through this agent. Ex: key1=value1,key2=${envVar:defaultValue}", resourceLabels)) + flags.String(resourceLabels, "", "One or more tags to be added to the Process tags of all spans passing through this agent. Ex: key1=value1,key2=${envVar:defaultValue}") +} diff --git a/cmd/opentelemetry-collector/app/processor/resourceprocessor/resource_processor.go b/cmd/opentelemetry-collector/app/processor/resourceprocessor/resource_processor.go index a4cfe891ab2..feb18e1e2fc 100644 --- a/cmd/opentelemetry-collector/app/processor/resourceprocessor/resource_processor.go +++ b/cmd/opentelemetry-collector/app/processor/resourceprocessor/resource_processor.go @@ -15,9 +15,6 @@ package resourceprocessor import ( - "flag" - "fmt" - "github.com/open-telemetry/opentelemetry-collector/component" "github.com/open-telemetry/opentelemetry-collector/config/configmodels" "github.com/open-telemetry/opentelemetry-collector/consumer" @@ -88,9 +85,3 @@ func (f Factory) CreateMetricsProcessor( ) (component.MetricsProcessorOld, error) { return f.Wrapped.CreateMetricsProcessor(logger, nextConsumer, cfg) } - -// AddFlags adds flags for Options. -func AddFlags(flags *flag.FlagSet) { - flags.String(reporter.AgentTagsDeprecated, "", fmt.Sprintf("(deprecated, use --%s) One or more tags to be added to the Process tags of all spans passing through this agent. Ex: key1=value1,key2=${envVar:defaultValue}", resourceLabels)) - flags.String(resourceLabels, "", "One or more tags to be added to the Process tags of all spans passing through this agent. Ex: key1=value1,key2=${envVar:defaultValue}") -} diff --git a/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/flags.go b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/flags.go new file mode 100644 index 00000000000..e0c7d8ef776 --- /dev/null +++ b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/flags.go @@ -0,0 +1,41 @@ +// Copyright (c) 2020 The Jaeger Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package jaegerreceiver + +import ( + "flag" + "strconv" + + agentApp "github.com/jaegertracing/jaeger/cmd/agent/app" + grpcRep "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" + collectorApp "github.com/jaegertracing/jaeger/cmd/collector/app" + "github.com/jaegertracing/jaeger/plugin/sampling/strategystore/static" + "github.com/jaegertracing/jaeger/ports" +) + +const ( + thriftBinaryHostPort = "processor.jaeger-binary.server-host-port" + thriftCompactHostPort = "processor.jaeger-compact.server-host-port" +) + +// AddFlags adds flags to flag set. +func AddFlags(flags *flag.FlagSet) { + flags.String(thriftBinaryHostPort, ":"+strconv.Itoa(ports.AgentJaegerThriftBinaryUDP), "host:port for the UDP server") + flags.String(thriftCompactHostPort, ":"+strconv.Itoa(ports.AgentJaegerThriftCompactUDP), "host:port for the UDP server") + collectorApp.AddOTELFlags(flags) + agentApp.AddOTELFlags(flags) + grpcRep.AddOTELFlags(flags) + static.AddOTELFlags(flags) +} diff --git a/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver.go b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver.go index f90f4ca8c12..54913d3ed3c 100644 --- a/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver.go +++ b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver.go @@ -20,10 +20,13 @@ import ( "github.com/open-telemetry/opentelemetry-collector/component" "github.com/open-telemetry/opentelemetry-collector/config/configmodels" "github.com/open-telemetry/opentelemetry-collector/consumer" + "github.com/open-telemetry/opentelemetry-collector/receiver" "github.com/open-telemetry/opentelemetry-collector/receiver/jaegerreceiver" "github.com/spf13/viper" - "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" + agentApp "github.com/jaegertracing/jaeger/cmd/agent/app" + grpcRep "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" + collectorApp "github.com/jaegertracing/jaeger/cmd/collector/app" "github.com/jaegertracing/jaeger/plugin/sampling/strategystore/static" ) @@ -48,9 +51,58 @@ func (f *Factory) Type() configmodels.Type { func (f *Factory) CreateDefaultConfig() configmodels.Receiver { cfg := f.Wrapped.CreateDefaultConfig().(*jaegerreceiver.Config) cfg.RemoteSampling = createDefaultSamplingConfig(f.Viper) + configureAgent(f.Viper, cfg) + configureCollector(f.Viper, cfg) return cfg } +func configureAgent(v *viper.Viper, cfg *jaegerreceiver.Config) { + aOpts := agentApp.Builder{} + aOpts.InitFromViper(v) + if v.IsSet(thriftBinaryHostPort) { + cfg.Protocols["thrift_binary"] = &receiver.SecureReceiverSettings{ + ReceiverSettings: configmodels.ReceiverSettings{ + // TODO OTEL does not expose number of workers and queue length + Endpoint: v.GetString(thriftBinaryHostPort), + }, + } + } + if v.IsSet(thriftCompactHostPort) { + cfg.Protocols["thrift_compact"] = &receiver.SecureReceiverSettings{ + ReceiverSettings: configmodels.ReceiverSettings{ + // TODO OTEL does not expose number of workers and queue length + Endpoint: v.GetString(thriftCompactHostPort), + }, + } + } +} + +func configureCollector(v *viper.Viper, cfg *jaegerreceiver.Config) { + cOpts := collectorApp.CollectorOptions{} + cOpts.InitFromViper(v) + if v.IsSet(collectorApp.CollectorGRPCHostPort) { + cfg.Protocols["grpc"] = &receiver.SecureReceiverSettings{ + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: cOpts.CollectorGRPCHostPort, + }, + } + if cOpts.TLS.CertPath != "" && cOpts.TLS.KeyPath != "" { + cfg.Protocols["grpc"].TLSCredentials = &receiver.TLSCredentials{ + // TODO client-ca is missing in OTEL https://github.com/open-telemetry/opentelemetry-collector/issues/963 + KeyFile: cOpts.TLS.KeyPath, + CertFile: cOpts.TLS.CertPath, + } + } + } + if v.IsSet(collectorApp.CollectorHTTPHostPort) { + cfg.Protocols["thrift_http"] = &receiver.SecureReceiverSettings{ + ReceiverSettings: configmodels.ReceiverSettings{ + Endpoint: cOpts.CollectorHTTPHostPort, + }, + } + } +} + func createDefaultSamplingConfig(v *viper.Viper) *jaegerreceiver.RemoteSamplingConfig { var samplingConf *jaegerreceiver.RemoteSamplingConfig strategyFile := v.GetString(static.SamplingStrategiesFile) @@ -59,7 +111,14 @@ func createDefaultSamplingConfig(v *viper.Viper) *jaegerreceiver.RemoteSamplingC StrategyFile: strategyFile, } } - repCfg := grpc.ConnBuilder{} + if v.IsSet(agentApp.HTTPServerHostPort) { + if samplingConf == nil { + samplingConf = &jaegerreceiver.RemoteSamplingConfig{} + } + samplingConf.HostEndpoint = v.GetString(agentApp.HTTPServerHostPort) + } + + repCfg := grpcRep.ConnBuilder{} repCfg.InitFromViper(v) // This is for agent mode. // This uses --reporter.grpc.host-port flag to set the fetch endpoint for the sampling strategies. @@ -68,7 +127,12 @@ func createDefaultSamplingConfig(v *viper.Viper) *jaegerreceiver.RemoteSamplingC if samplingConf == nil { samplingConf = &jaegerreceiver.RemoteSamplingConfig{} } - samplingConf.FetchEndpoint = repCfg.CollectorHostPorts[0] + samplingConf.GRPCSettings.Endpoint = repCfg.CollectorHostPorts[0] + samplingConf.GRPCSettings.TLSConfig.UseSecure = repCfg.TLS.Enabled + samplingConf.GRPCSettings.TLSConfig.CaCert = repCfg.TLS.CAPath + samplingConf.GRPCSettings.TLSConfig.ClientCert = repCfg.TLS.CertPath + samplingConf.GRPCSettings.TLSConfig.ClientKey = repCfg.TLS.KeyPath + samplingConf.GRPCSettings.TLSConfig.ServerNameOverride = repCfg.TLS.ServerName } return samplingConf } diff --git a/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver_test.go b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver_test.go index 48335f4a258..8e0ef6a6c54 100644 --- a/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver_test.go +++ b/cmd/opentelemetry-collector/app/receiver/jaegerreceiver/jaeger_receiver_test.go @@ -16,50 +16,149 @@ package jaegerreceiver import ( "context" + "fmt" "path" "testing" "github.com/open-telemetry/opentelemetry-collector/component" "github.com/open-telemetry/opentelemetry-collector/config" "github.com/open-telemetry/opentelemetry-collector/config/configerror" + "github.com/open-telemetry/opentelemetry-collector/config/configgrpc" "github.com/open-telemetry/opentelemetry-collector/config/configmodels" + "github.com/open-telemetry/opentelemetry-collector/receiver" "github.com/open-telemetry/opentelemetry-collector/receiver/jaegerreceiver" - "github.com/spf13/viper" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + collectorApp "github.com/jaegertracing/jaeger/cmd/collector/app" jConfig "github.com/jaegertracing/jaeger/pkg/config" "github.com/jaegertracing/jaeger/plugin/sampling/strategystore/static" ) func TestDefaultValues(t *testing.T) { - v, c := jConfig.Viperize(static.AddFlags) + v, c := jConfig.Viperize(AddFlags) err := c.ParseFlags([]string{}) require.NoError(t, err) factory := &Factory{Viper: v, Wrapped: &jaegerreceiver.Factory{}} cfg := factory.CreateDefaultConfig().(*jaegerreceiver.Config) assert.Nil(t, cfg.RemoteSampling) + assert.Empty(t, cfg.Protocols) } func TestDefaultValueFromViper(t *testing.T) { - v := viper.New() - v.Set(static.SamplingStrategiesFile, "config.json") - - f := &Factory{ - Wrapped: &jaegerreceiver.Factory{}, - Viper: v, + tests := []struct { + name string + flags []string + expected *jaegerreceiver.Config + }{ + { + name: "samplingStrategyFile", + flags: []string{fmt.Sprintf("--%s=%s", static.SamplingStrategiesFile, "conf.json")}, + expected: &jaegerreceiver.Config{ + RemoteSampling: &jaegerreceiver.RemoteSamplingConfig{ + StrategyFile: "conf.json", + }, + Protocols: map[string]*receiver.SecureReceiverSettings{}, + }, + }, + { + name: "thriftCompact", + flags: []string{fmt.Sprintf("--%s=%s", thriftCompactHostPort, "localhost:9999")}, + expected: &jaegerreceiver.Config{ + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_compact": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:9999"}}, + }, + }, + }, + { + name: "thriftBinary", + flags: []string{fmt.Sprintf("--%s=%s", thriftBinaryHostPort, "localhost:8888")}, + expected: &jaegerreceiver.Config{ + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_binary": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:8888"}}, + }, + }, + }, + { + name: "grpc", + flags: []string{fmt.Sprintf("--%s=%s", collectorApp.CollectorGRPCHostPort, "localhost:7894")}, + expected: &jaegerreceiver.Config{ + Protocols: map[string]*receiver.SecureReceiverSettings{ + "grpc": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:7894"}}, + }, + }, + }, + { + name: "thriftHttp", + flags: []string{fmt.Sprintf("--%s=%s", collectorApp.CollectorHTTPHostPort, "localhost:8080")}, + expected: &jaegerreceiver.Config{ + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_http": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:8080"}}, + }, + }, + }, + { + name: "thriftHttpAndThriftBinary", + flags: []string{fmt.Sprintf("--%s=%s", collectorApp.CollectorHTTPHostPort, "localhost:8089"), fmt.Sprintf("--%s=%s", thriftBinaryHostPort, "localhost:2222")}, + expected: &jaegerreceiver.Config{ + Protocols: map[string]*receiver.SecureReceiverSettings{ + "thrift_http": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:8089"}}, + "thrift_binary": {ReceiverSettings: configmodels.ReceiverSettings{Endpoint: "localhost:2222"}}, + }, + }, + }, + { + name: "remoteSampling", + flags: []string{ + "--http-server.host-port=machine:1", + "--sampling.strategies-file=foo", + "--reporter.grpc.host-port=coll:33", + "--reporter.grpc.tls.enabled=true", + "--reporter.grpc.tls.ca=cacert.pem", + "--reporter.grpc.tls.cert=cert.pem", + "--reporter.grpc.tls.key=key.key", + }, + expected: &jaegerreceiver.Config{ + RemoteSampling: &jaegerreceiver.RemoteSamplingConfig{ + StrategyFile: "foo", + HostEndpoint: "machine:1", + GRPCSettings: configgrpc.GRPCSettings{ + Endpoint: "coll:33", + TLSConfig: configgrpc.TLSConfig{ + UseSecure: true, + CaCert: "cacert.pem", + ClientCert: "cert.pem", + ClientKey: "key.key", + }, + }, + }, + Protocols: map[string]*receiver.SecureReceiverSettings{}, + }, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + v, c := jConfig.Viperize(AddFlags) + err := c.ParseFlags(test.flags) + require.NoError(t, err) + f := &Factory{ + Wrapped: &jaegerreceiver.Factory{}, + Viper: v, + } + cfg := f.CreateDefaultConfig().(*jaegerreceiver.Config) + test.expected.TypeVal = "jaeger" + test.expected.NameVal = "jaeger" + assert.Equal(t, test.expected, cfg) + }) } - - cfg := f.CreateDefaultConfig().(*jaegerreceiver.Config) - assert.Equal(t, "config.json", cfg.RemoteSampling.StrategyFile) } func TestLoadConfigAndFlags(t *testing.T) { factories, err := config.ExampleComponents() require.NoError(t, err) - v, c := jConfig.Viperize(static.AddFlags) + v, c := jConfig.Viperize(AddFlags) err = c.ParseFlags([]string{"--sampling.strategies-file=bar.json"}) require.NoError(t, err) diff --git a/cmd/opentelemetry-collector/cmd/agent/main.go b/cmd/opentelemetry-collector/cmd/agent/main.go index 508627d12c5..b9d0adcb00b 100644 --- a/cmd/opentelemetry-collector/cmd/agent/main.go +++ b/cmd/opentelemetry-collector/cmd/agent/main.go @@ -25,13 +25,11 @@ import ( "github.com/open-telemetry/opentelemetry-collector/service/builder" "github.com/spf13/viper" - "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" jflags "github.com/jaegertracing/jaeger/cmd/flags" + "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/defaults" - "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/processor/resourceprocessor" jconfig "github.com/jaegertracing/jaeger/pkg/config" "github.com/jaegertracing/jaeger/pkg/version" - "github.com/jaegertracing/jaeger/plugin/sampling/strategystore/static" ) func main() { @@ -77,10 +75,7 @@ func main() { cmd := svc.Command() jconfig.AddFlags(v, cmd, - jflags.AddConfigFileFlag, - grpc.AddFlags, - static.AddFlags, - resourceprocessor.AddFlags, + app.AddComponentFlags, ) // parse flags to propagate Jaeger config file flag value to viper diff --git a/cmd/opentelemetry-collector/cmd/collector/main.go b/cmd/opentelemetry-collector/cmd/collector/main.go index 5282fa48b18..4bd5073706c 100644 --- a/cmd/opentelemetry-collector/cmd/collector/main.go +++ b/cmd/opentelemetry-collector/cmd/collector/main.go @@ -25,15 +25,12 @@ import ( "github.com/open-telemetry/opentelemetry-collector/service/builder" "github.com/spf13/viper" - "github.com/jaegertracing/jaeger/cmd/agent/app/reporter/grpc" collectorApp "github.com/jaegertracing/jaeger/cmd/collector/app" jflags "github.com/jaegertracing/jaeger/cmd/flags" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/defaults" - "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/processor/resourceprocessor" jConfig "github.com/jaegertracing/jaeger/pkg/config" "github.com/jaegertracing/jaeger/pkg/version" - "github.com/jaegertracing/jaeger/plugin/sampling/strategystore/static" "github.com/jaegertracing/jaeger/plugin/storage" ) @@ -89,19 +86,15 @@ func main() { // Add Jaeger specific flags to service command // this passes flag values to viper. - storageFlags, err := app.StorageFlags(storageType) + storageFlags, err := app.AddStorageFlags(storageType) if err != nil { handleErr(err) } cmd := svc.Command() jConfig.AddFlags(v, cmd, - collectorApp.AddFlags, - jflags.AddConfigFileFlag, + app.AddComponentFlags, storageFlags, - static.AddFlags, - grpc.AddFlags, - resourceprocessor.AddFlags, ) // parse flags to propagate Jaeger config file flag value to viper diff --git a/cmd/opentelemetry-collector/cmd/ingester/main.go b/cmd/opentelemetry-collector/cmd/ingester/main.go index 4564f4123e9..2729ac71ace 100644 --- a/cmd/opentelemetry-collector/cmd/ingester/main.go +++ b/cmd/opentelemetry-collector/cmd/ingester/main.go @@ -26,7 +26,6 @@ import ( "github.com/spf13/viper" jflags "github.com/jaegertracing/jaeger/cmd/flags" - ingesterApp "github.com/jaegertracing/jaeger/cmd/ingester/app" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app" "github.com/jaegertracing/jaeger/cmd/opentelemetry-collector/app/defaults" jconfig "github.com/jaegertracing/jaeger/pkg/config" @@ -84,7 +83,7 @@ func main() { // Add Jaeger specific flags to service command // this passes flag values to viper. - storageFlags, err := app.StorageFlags(storageType) + storageFlags, err := app.AddStorageFlags(storageType) if err != nil { handleErr(err) } @@ -92,8 +91,7 @@ func main() { cmd := svc.Command() jconfig.AddFlags(v, cmd, - jflags.AddConfigFileFlag, - ingesterApp.AddFlags, + app.AddComponentFlags, storageFlags, ) diff --git a/cmd/opentelemetry-collector/go.mod b/cmd/opentelemetry-collector/go.mod index 32687c0779f..d6bd9bd5c03 100644 --- a/cmd/opentelemetry-collector/go.mod +++ b/cmd/opentelemetry-collector/go.mod @@ -10,7 +10,7 @@ require ( github.com/Shopify/sarama v1.22.2-0.20190604114437-cd910a683f9f github.com/imdario/mergo v0.3.9 github.com/jaegertracing/jaeger v1.17.0 - github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200505202444-021607d68586 + github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200512031848-f588c89b4778 github.com/open-telemetry/opentelemetry-proto v0.3.0 github.com/spf13/pflag v1.0.5 github.com/spf13/viper v1.6.2 diff --git a/cmd/opentelemetry-collector/go.sum b/cmd/opentelemetry-collector/go.sum index 9b24761d417..d5a25b2aba9 100644 --- a/cmd/opentelemetry-collector/go.sum +++ b/cmd/opentelemetry-collector/go.sum @@ -954,6 +954,8 @@ github.com/onsi/gomega v1.9.0 h1:R1uwffexN6Pr340GtYRIdZmAiN4J+iw6WG4wog1DUXg= github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA= github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200505202444-021607d68586 h1:HD0/Opa/WiWaG+B6LP+5XT9lYqpErWd6DjH3ah9mQrU= github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200505202444-021607d68586/go.mod h1:ht/uOm+HLoXWjhq6seX/BoTwlR0dtCKFe2Y23YRk2a4= +github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200512031848-f588c89b4778 h1:wcE5bWypMq95vlZGikUklYB6VPyg3pke/32nei5/Sww= +github.com/open-telemetry/opentelemetry-collector v0.3.1-0.20200512031848-f588c89b4778/go.mod h1:+q6GyqO1FHatlq93uplydIVjRhBrv04oQ23AbOqcn6E= github.com/open-telemetry/opentelemetry-proto v0.3.0 h1:+ASAtcayvoELyCF40+rdCMlBOhZIn5TPDez85zSYc30= github.com/open-telemetry/opentelemetry-proto v0.3.0/go.mod h1:PMR5GI0F7BSpio+rBGFxNm6SLzg3FypDTcFuQZnO+F8= github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= @@ -968,6 +970,8 @@ github.com/openzipkin/zipkin-go v0.2.1 h1:noL5/5Uf1HpVl3wNsfkZhIKbSWCVi5jgqkONNx github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= github.com/orijtech/prometheus-go-metrics-exporter v0.0.4 h1:AAHKuTu2lX4eMPKV+CRcTug9KdMZ/Ckez7KK+ddEQfM= github.com/orijtech/prometheus-go-metrics-exporter v0.0.4/go.mod h1:BiTx/ugZex8LheBk3j53tktWaRdFjV5FCfT2o0P7msE= +github.com/orijtech/prometheus-go-metrics-exporter v0.0.5 h1:76JFgRIgNDA3pW1fUhmqinU2u5ndHv1gvapDfGG+7/c= +github.com/orijtech/prometheus-go-metrics-exporter v0.0.5/go.mod h1:BiTx/ugZex8LheBk3j53tktWaRdFjV5FCfT2o0P7msE= github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs= github.com/ory/dockertest/v3 v3.5.4/go.mod h1:J8ZUbNB2FOhm1cFZW9xBpDsODqsSWcyYgtJYVPcnF70= github.com/ory/fosite v0.29.0/go.mod h1:0atSZmXO7CAcs6NPMI/Qtot8tmZYj04Nddoold4S2h0= diff --git a/crossdock/jaeger-docker-compose.yml b/crossdock/jaeger-docker-compose.yml index fe3c90d14f6..84218978456 100644 --- a/crossdock/jaeger-docker-compose.yml +++ b/crossdock/jaeger-docker-compose.yml @@ -3,7 +3,7 @@ version: '2' services: jaeger-collector: image: jaegertracing/jaeger-collector - command: ["--es.num-shards=1", "--es.num-replicas=0", "--es.server-urls=http://elasticsearch:9200", "--collector.zipkin.http-port=9411"] + command: ["--es.num-shards=1", "--es.num-replicas=0", "--es.server-urls=http://elasticsearch:9200", "--collector.zipkin.host-port=:9411"] ports: - "14269" - "14268:14268" diff --git a/crossdock/jaeger-opentelemetry-docker-compose.yml b/crossdock/jaeger-opentelemetry-docker-compose.yml index 406fefc8d02..35d16428600 100644 --- a/crossdock/jaeger-opentelemetry-docker-compose.yml +++ b/crossdock/jaeger-opentelemetry-docker-compose.yml @@ -3,7 +3,7 @@ version: '2' services: jaeger-collector: image: jaegertracing/jaeger-opentelemetry-collector - command: ["--es.num-shards=1", "--es.num-replicas=0", "--es.server-urls=http://elasticsearch:9200", "--collector.zipkin.http-port=9411"] + command: ["--es.num-shards=1", "--es.num-replicas=0", "--es.server-urls=http://elasticsearch:9200", "--collector.zipkin.host-port=:9411"] ports: - "14250" - "14268" diff --git a/plugin/sampling/strategystore/static/options.go b/plugin/sampling/strategystore/static/options.go index ffc55ba870c..0ef18fbf2ea 100644 --- a/plugin/sampling/strategystore/static/options.go +++ b/plugin/sampling/strategystore/static/options.go @@ -37,8 +37,13 @@ type Options struct { // AddFlags adds flags for Options func AddFlags(flagSet *flag.FlagSet) { - flagSet.String(SamplingStrategiesFile, "", "The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file") flagSet.Duration(samplingStrategiesReloadInterval, 0, "Reload interval to check and reload sampling strategies file. Zero value means no reloading") + AddOTELFlags(flagSet) +} + +// AddOTELFlags adds flags that are exposed by OTEL collector +func AddOTELFlags(flagSet *flag.FlagSet) { + flagSet.String(SamplingStrategiesFile, "", "The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file") } // InitFromViper initializes Options with properties from viper