Added sync analytics (#161)

* Added analytics that do not use goroutines to help debug a scheduling issue (golang/go#54061).
Co-authored-by: Olivér Falvai <[email protected]>

Author: lpusok

analytics/client.go

@@ -2,6 +2,7 @@ package analytics
 
 import (
 	"bytes"
+	"context"
 	"net/http"
 	"time"
 
@@ -10,7 +11,6 @@ import (
 )
 
 const trackEndpoint = "https://bitrise-step-analytics.herokuapp.com/track"
-const timeOut = 30 * time.Second
 
 // Client ...
 type Client interface {
@@ -19,29 +19,47 @@ type Client interface {
 
 type client struct {
 	httpClient *http.Client
+	timeout    time.Duration
 	endpoint   string
 	logger     log.Logger
 }
 
 // NewDefaultClient ...
-func NewDefaultClient(logger log.Logger) Client {
+func NewDefaultClient(logger log.Logger, timeout time.Duration) Client {
 	httpClient := retry.NewHTTPClient().StandardClient()
-	httpClient.Timeout = timeOut
-	return NewClient(httpClient, trackEndpoint, logger)
+	httpClient.Timeout = timeout
+	return NewClient(httpClient, trackEndpoint, logger, timeout)
 }
 
 // NewClient ...
-func NewClient(httpClient *http.Client, endpoint string, logger log.Logger) Client {
-	return client{httpClient: httpClient, endpoint: endpoint, logger: logger}
+func NewClient(httpClient *http.Client, endpoint string, logger log.Logger, timeout time.Duration) Client {
+	return client{httpClient: httpClient, endpoint: endpoint, logger: logger, timeout: timeout}
 }
 
 // Send ...
 func (t client) Send(buffer *bytes.Buffer) {
-	res, err := t.httpClient.Post(t.endpoint, "application/json", buffer)
+	ctx, cancel := context.WithTimeout(context.Background(), t.timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.endpoint, buffer)
 	if err != nil {
-		t.logger.Debugf("Couldn't send analytics event: %s", err.Error())
+		t.logger.Warnf("Couldn't create analytics request: %s", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	res, err := t.httpClient.Do(req)
+	if err != nil {
+		t.logger.Debugf("Couldn't send analytics event: %s", err)
 		return
 	}
+
+	defer func() {
+		if err := res.Body.Close(); err != nil {
+			t.logger.Debugf("Couldn't close anaytics body: %s", err)
+		}
+	}()
+
 	if statusOK := res.StatusCode >= 200 && res.StatusCode < 300; !statusOK {
 		t.logger.Debugf("Couldn't send analytics event, status code: %d", res.StatusCode)
 	}

analytics/client_test.go

@@ -6,12 +6,15 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/bitrise-io/go-utils/v2/analytics/mocks"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
+const cientTimeout = 10 * time.Second
+
 func Test_trackerClient_send_success(t *testing.T) {
 	mockLogger := new(mocks.Logger)
 	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
@@ -25,7 +28,7 @@ func Test_trackerClient_send_success(t *testing.T) {
 		assert.NoError(t, err)
 	}))
 	defer func() { testServer.Close() }()
-	client := NewClient(http.DefaultClient, testServer.URL, mockLogger)
+	client := NewClient(http.DefaultClient, testServer.URL, mockLogger, cientTimeout)
 	client.Send(bytes.NewBufferString("{}"))
 	mockLogger.AssertNotCalled(t, "Debugf", mock.Anything, mock.Anything)
 }
@@ -44,7 +47,7 @@ func Test_trackerClient_send_failure(t *testing.T) {
 		assert.NoError(t, err)
 	}))
 	defer func() { testServer.Close() }()
-	client := NewClient(http.DefaultClient, testServer.URL, mockLogger)
+	client := NewClient(http.DefaultClient, testServer.URL, mockLogger, cientTimeout)
 	client.Send(bytes.NewBufferString("{}"))
 	mockLogger.AssertCalled(t, "Debugf", "Couldn't send analytics event, status code: %d", 500)
 }

analytics/sync_track.go

@@ -0,0 +1,39 @@
+package analytics
+
+import (
+	"bytes"
+	"time"
+
+	"github.com/bitrise-io/go-utils/v2/log"
+)
+
+const syncClientTimeout = 10 * time.Second
+
+type syncTracker struct {
+	client     Client
+	properties []Properties
+}
+
+// NewDefaultSyncTracker ...
+func NewDefaultSyncTracker(logger log.Logger, properties ...Properties) Tracker {
+	return NewSyncTracker(NewDefaultClient(logger, syncClientTimeout), properties...)
+}
+
+// NewSyncTracker ...
+func NewSyncTracker(client Client, properties ...Properties) Tracker {
+	t := syncTracker{client: client, properties: properties}
+	return &t
+}
+
+// Enqueue ...
+func (t syncTracker) Enqueue(eventName string, properties ...Properties) {
+	var b bytes.Buffer
+
+	newEvent(eventName, append(t.properties, properties...)).toJSON(&b)
+	t.client.Send(&b)
+}
+
+// Wait ...
+func (t syncTracker) Wait() {
+	// no-op in sync tracker
+}

analytics/sync_track_test.go

@@ -0,0 +1,92 @@
+package analytics
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/bitrise-io/go-utils/v2/analytics/mocks"
+	"github.com/stretchr/testify/mock"
+)
+
+func Test_syncTracker_SendIsCalledWithExpectedData(t *testing.T) {
+	mockClient := new(mocks.Client)
+	mockClient.On("Send", mock.Anything).Return()
+
+	tracker := NewSyncTracker(mockClient)
+	baseProperties := Properties{"session": "id"}
+	tracker.Enqueue(
+		"first",
+		baseProperties, Properties{
+			"property":      "value",
+			"intproperty":   42,
+			"longproperty":  42,
+			"floatproperty": 3.14,
+			"boolproperty":  true,
+			"property2":     Properties{"foo": "bar"},
+		},
+	)
+	tracker.Wait()
+
+	matcher := mock.MatchedBy(func(buffer *bytes.Buffer) bool {
+		var event event
+		err := json.Unmarshal(buffer.Bytes(), &event)
+		if err != nil {
+			return false
+		}
+		if event.EventName != "first" {
+			return false
+		}
+		if len(event.Properties) != 7 ||
+			event.Properties["property"] != "value" ||
+			event.Properties["intproperty"].(float64) != 42 ||
+			event.Properties["longproperty"].(float64) != 42 ||
+			event.Properties["floatproperty"].(float64) != 3.14 ||
+			event.Properties["boolproperty"].(bool) != true ||
+			event.Properties["session"] != "id" ||
+			event.Properties["property2"].(map[string]interface{})["foo"] != "bar" {
+			return false
+		}
+		if event.ID == "" || event.Timestamp == 0 {
+			return false
+		}
+		return true
+	})
+	mockClient.AssertNumberOfCalls(t, "Send", 1)
+	mockClient.AssertCalled(t, "Send", matcher)
+}
+
+func Test_syncTracker_MergingPropertiesWork(t *testing.T) {
+	mockClient := new(mocks.Client)
+	mockClient.On("Send", mock.Anything).Return()
+
+	tracker := NewSyncTracker(mockClient, Properties{"base": "base"})
+	baseProperties := Properties{"first": "first"}
+	tracker.Enqueue("event", baseProperties)
+	newBaseProperties := baseProperties.Merge(Properties{"second": "second"})
+	tracker.Enqueue("event2", newBaseProperties)
+	tracker.Wait()
+
+	mockClient.AssertNumberOfCalls(t, "Send", 2)
+	matcher := mock.MatchedBy(func(buffer *bytes.Buffer) bool {
+		var event event
+		err := json.Unmarshal(buffer.Bytes(), &event)
+		if err != nil {
+			return false
+		}
+		if event.EventName == "event" {
+			if len(event.Properties) != 2 || event.Properties["base"] != "base" || event.Properties["first"] != "first" {
+				return false
+			}
+			return true
+		}
+		if event.EventName == "event2" {
+			if len(event.Properties) != 3 || event.Properties["base"] != "base" || event.Properties["first"] != "first" || event.Properties["second"] != "second" {
+				return false
+			}
+			return true
+		}
+		return false
+	})
+	mockClient.AssertCalled(t, "Send", matcher)
+}

analytics/track.go

@@ -11,6 +11,7 @@ import (
 const poolSize = 10
 const bufferSize = 100
 const timeout = 30 * time.Second
+const asyncClientTimeout = 30 * time.Second
 
 // Tracker ...
 type Tracker interface {
@@ -28,7 +29,7 @@ type tracker struct {
 
 // NewDefaultTracker ...
 func NewDefaultTracker(logger log.Logger, properties ...Properties) Tracker {
-	return NewTracker(NewDefaultClient(logger), timeout, properties...)
+	return NewTracker(NewDefaultClient(logger, asyncClientTimeout), timeout, properties...)
 }
 
 // NewTracker ...