bug: address parsing wavefront urls with a path component

Author: LukeWinikates

internal/reporter.go

@@ -32,22 +32,38 @@ func (reporter reporter) Report(format string, pointLines string) (*http.Respons
 		return nil, formatError
 	}
 
-	// compress
+	buf, err := linesToBuffer(pointLines)
+	if err != nil {
+		return &http.Response{}, err
+	}
+
+	req, err := reporter.buildRequest(format, buf)
+	if err != nil {
+		return &http.Response{}, err
+	}
+
+	return reporter.execute(req)
+}
+
+func linesToBuffer(pointLines string) (bytes.Buffer, error) {
 	var buf bytes.Buffer
 	zw := gzip.NewWriter(&buf)
 	_, err := zw.Write([]byte(pointLines))
 	if err != nil {
 		zw.Close()
-		return nil, err
+		return bytes.Buffer{}, err
 	}
 	if err = zw.Close(); err != nil {
-		return nil, err
+		return bytes.Buffer{}, err
 	}
+	return buf, err
+}
 
+func (reporter reporter) buildRequest(format string, buf bytes.Buffer) (*http.Request, error) {
 	apiURL := reporter.serverURL + reportEndpoint
 	req, err := http.NewRequest("POST", apiURL, &buf)
 	if err != nil {
-		return &http.Response{}, err
+		return nil, err
 	}
 
 	req.Header.Set(contentType, octetStream)
@@ -59,8 +75,7 @@ func (reporter reporter) Report(format string, pointLines string) (*http.Respons
 	q := req.URL.Query()
 	q.Add(formatKey, format)
 	req.URL.RawQuery = q.Encode()
-
-	return reporter.execute(req)
+	return req, nil
 }
 
 func (reporter reporter) ReportEvent(event string) (*http.Response, error) {

internal/reporter_test.go

@@ -0,0 +1,17 @@
+package internal
+
+import (
+	"bytes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestBuildRequest(t *testing.T) {
+	var r *reporter
+	var buf bytes.Buffer
+	r = NewReporter("http://localhost:8010/wavefront", "").(*reporter)
+	request, err := r.buildRequest("wavefront", buf)
+	require.NoError(t, err)
+	assert.Equal(t, "http://localhost:8010/wavefront/report?f=wavefront", request.URL.String())
+}

senders/client_factory.go

@@ -44,6 +44,7 @@ type configuration struct {
 	// together with batch size controls the max theoretical throughput of the sender.
 	FlushIntervalSeconds int
 	SDKMetricsTags       map[string]string
+	Path                 string
 }
 
 func (c *configuration) Direct() bool {
@@ -106,6 +107,11 @@ func CreateConfig(wfURL string, setters ...Option) (*configuration, error) {
 		return nil, fmt.Errorf("invalid scheme '%s' in '%s', only 'http' is supported", u.Scheme, u)
 	}
 
+	if u.Path != "" {
+		cfg.Path = u.Path
+		u.Path = ""
+	}
+
 	if u.Port() != "" {
 		port, err := strconv.Atoi(u.Port())
 		if err != nil {
@@ -124,8 +130,8 @@ func CreateConfig(wfURL string, setters ...Option) (*configuration, error) {
 
 // newWavefrontClient creates a Wavefront sender
 func newWavefrontClient(cfg *configuration) (Sender, error) {
-	metricsReporter := internal.NewReporter(fmt.Sprintf("%s:%d", cfg.Server, cfg.MetricsPort), cfg.Token)
-	tracesReporter := internal.NewReporter(fmt.Sprintf("%s:%d", cfg.Server, cfg.TracesPort), cfg.Token)
+	metricsReporter := internal.NewReporter(MetricsURL(cfg), cfg.Token)
+	tracesReporter := internal.NewReporter(TracesURL(cfg), cfg.Token)
 
 	sender := &wavefrontSender{
 		defaultSource: internal.GetHostname("wavefront_direct_sender"),
@@ -142,6 +148,14 @@ func newWavefrontClient(cfg *configuration) (Sender, error) {
 	return sender, nil
 }
 
+func TracesURL(cfg *configuration) string {
+	return fmt.Sprintf("%s:%d%s", cfg.Server, cfg.TracesPort, cfg.Path)
+}
+
+func MetricsURL(cfg *configuration) string {
+	return fmt.Sprintf("%s:%d%s", cfg.Server, cfg.MetricsPort, cfg.Path)
+}
+
 func (sender *wavefrontSender) initializeInternalMetrics(cfg *configuration) {
 
 	var setters []internal.RegistryOption

senders/client_factory_test.go

@@ -65,6 +65,22 @@ func TestPortExtractedFromURL(t *testing.T) {
 	assert.Equal(t, 1234, cfg.TracesPort)
 }
 
+func TestUrlWithPortAndPath(t *testing.T) {
+	cfg, err := senders.CreateConfig("http://localhost:8071/wavefront")
+	require.NoError(t, err)
+	assert.Equal(t, 8071, cfg.MetricsPort)
+	assert.Equal(t, 8071, cfg.TracesPort)
+	assert.Equal(t, "http://localhost", cfg.Server)
+	assert.Equal(t, "/wavefront", cfg.Path)
+}
+
+func TestMetricsURLWithPortAndPath(t *testing.T) {
+	cfg, err := senders.CreateConfig("http://localhost:8071/wavefront")
+	require.NoError(t, err)
+	assert.Equal(t, "http://localhost:8071/wavefront", senders.MetricsURL(cfg))
+	assert.Equal(t, "http://localhost:8071/wavefront", senders.TracesURL(cfg))
+}
+
 func TestToken(t *testing.T) {
 	cfg, err := senders.CreateConfig("https://my-api-token@localhost")
 	require.NoError(t, err)