Update split SDK to 6.0.2 to fix sync bug (#17060)

* Update split SDK to 6.0.2 to fix sync bug

* Vendor and tidy

vendor/github.com/splitio/go-split-commons/v3/service/api/auth.go

@@ -0,0 +1,39 @@
+package api
+
+import (
+	"encoding/json"
+
+	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-split-commons/v3/dtos"
+	"github.com/splitio/go-toolkit/v4/logging"
+)
+
+// AuthAPIClient struct is responsible for authenticating client for push services
+type AuthAPIClient struct {
+	client Client
+	logger logging.LoggerInterface
+}
+
+// NewAuthAPIClient instantiates and return an AuthAPIClient
+func NewAuthAPIClient(apikey string, cfg conf.AdvancedConfig, logger logging.LoggerInterface, metadata dtos.Metadata) *AuthAPIClient {
+	return &AuthAPIClient{
+		client: NewHTTPClient(apikey, cfg, cfg.AuthServiceURL, logger, metadata),
+		logger: logger,
+	}
+}
+
+// Authenticate performs authentication for push services
+func (a *AuthAPIClient) Authenticate() (*dtos.Token, error) {
+	raw, err := a.client.Get("/api/auth", map[string]string{CacheControlHeader: CacheControlNoCache})
+	if err != nil {
+		a.logger.Error("Error while authenticating for streaming", err)
+		return nil, err
+	}
+
+	token := dtos.Token{}
+	err = json.Unmarshal(raw, &token)
+	if err != nil {
+		return nil, err
+	}
+	return &token, nil
+}

vendor/github.com/splitio/go-split-commons/v3/service/api/client.go

@@ -0,0 +1,169 @@
+package api
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-split-commons/v3/dtos"
+	"github.com/splitio/go-toolkit/v4/logging"
+)
+
+// Cache control header constants
+const (
+	CacheControlHeader  = "Cache-Control"
+	CacheControlNoCache = "no-cache"
+)
+
+// Client interface for HTTPClient
+type Client interface {
+	Get(service string, headers map[string]string) ([]byte, error)
+	Post(service string, body []byte, headers map[string]string) error
+}
+
+// HTTPClient structure to wrap up the net/http.Client
+type HTTPClient struct {
+	url        string
+	httpClient *http.Client
+	headers    map[string]string
+	logger     logging.LoggerInterface
+	apikey     string
+	metadata   dtos.Metadata
+}
+
+// NewHTTPClient instance of HttpClient
+func NewHTTPClient(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	endpoint string,
+	logger logging.LoggerInterface,
+	metadata dtos.Metadata,
+) Client {
+	var timeout int
+	timeout = cfg.HTTPTimeout
+	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	return &HTTPClient{
+		url:        endpoint,
+		httpClient: client,
+		logger:     logger,
+		apikey:     apikey,
+		metadata:   metadata,
+	}
+}
+
+// Get method is a get call to an url
+func (c *HTTPClient) Get(service string, headers map[string]string) ([]byte, error) {
+	serviceURL := c.url + service
+	c.logger.Debug("[GET] ", serviceURL)
+	req, _ := http.NewRequest("GET", serviceURL, nil)
+
+	authorization := c.apikey
+	c.logger.Debug("Authorization [ApiKey]: ", logging.ObfuscateAPIKey(authorization))
+	req.Header.Add("Accept-Encoding", "gzip")
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Add("SplitSDKVersion", c.metadata.SDKVersion)
+	req.Header.Add("SplitSDKMachineName", c.metadata.MachineName)
+	req.Header.Add("SplitSDKMachineIP", c.metadata.MachineIP)
+
+	for headerName, headerValue := range headers {
+		req.Header.Add(headerName, headerValue)
+	}
+
+	c.logger.Debug(fmt.Sprintf("Headers: %v", req.Header))
+
+	req.Header.Add("Authorization", "Bearer "+authorization)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		c.logger.Error("Error requesting data to API: ", req.URL.String(), err.Error())
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// Check that the server actually sent compressed data
+	var reader io.ReadCloser
+	switch resp.Header.Get("Content-Encoding") {
+	case "gzip":
+		reader, err = gzip.NewReader(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing gzip resopnse body: %w", err)
+		}
+		defer reader.Close()
+	default:
+		reader = resp.Body
+	}
+
+	body, err := ioutil.ReadAll(reader)
+	if err != nil {
+		c.logger.Error(err.Error())
+		return nil, err
+	}
+
+	c.logger.Verbose("[RESPONSE_BODY]", string(body), "[END_RESPONSE_BODY]")
+
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return body, nil
+	}
+
+	c.logger.Error(fmt.Sprintf("GET method: Status Code: %d - %s", resp.StatusCode, resp.Status))
+	return nil, &dtos.HTTPError{
+		Code:    resp.StatusCode,
+		Message: resp.Status,
+	}
+}
+
+// Post performs a HTTP POST request
+func (c *HTTPClient) Post(service string, body []byte, headers map[string]string) error {
+
+	serviceURL := c.url + service
+	c.logger.Debug("[POST] ", serviceURL)
+	req, _ := http.NewRequest("POST", serviceURL, bytes.NewBuffer(body))
+	//****************
+	req.Close = true // To prevent EOF error when connection is closed
+	//****************
+	authorization := c.apikey
+	c.logger.Debug("Authorization [ApiKey]: ", logging.ObfuscateAPIKey(authorization))
+
+	req.Header.Add("Accept-Encoding", "gzip")
+	req.Header.Add("Content-Type", "application/json")
+
+	for headerName, headerValue := range headers {
+		req.Header.Add(headerName, headerValue)
+	}
+
+	c.logger.Debug(fmt.Sprintf("Headers: %v", req.Header))
+
+	req.Header.Add("Authorization", "Bearer "+authorization)
+
+	c.logger.Verbose("[REQUEST_BODY]", string(body), "[END_REQUEST_BODY]")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		c.logger.Error("Error posting data to API: ", req.URL.String(), err.Error())
+		return err
+	}
+	defer resp.Body.Close()
+
+	respBody, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		c.logger.Error(err.Error())
+		return err
+	}
+
+	c.logger.Verbose("[RESPONSE_BODY]", string(respBody), "[END_RESPONSE_BODY]")
+
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+
+	c.logger.Error(fmt.Sprintf("POST method: Status Code: %d - %s", resp.StatusCode, resp.Status))
+	return &dtos.HTTPError{
+		Code:    resp.StatusCode,
+		Message: resp.Status,
+	}
+}

vendor/github.com/splitio/go-split-commons/v3/service/api/http_fetchers.go

@@ -0,0 +1,115 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"strconv"
+
+	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-split-commons/v3/dtos"
+	"github.com/splitio/go-toolkit/v4/logging"
+)
+
+type httpFetcherBase struct {
+	client Client
+	logger logging.LoggerInterface
+}
+
+func (h *httpFetcherBase) fetchRaw(url string, since int64, requestNoCache bool) ([]byte, error) {
+	var bufferQuery bytes.Buffer
+	bufferQuery.WriteString(url)
+
+	if since >= -1 {
+		bufferQuery.WriteString("?since=")
+		bufferQuery.WriteString(strconv.FormatInt(since, 10))
+	}
+
+	var extraHeaders map[string]string
+	if requestNoCache {
+		extraHeaders = map[string]string{CacheControlHeader: CacheControlNoCache}
+	}
+	data, err := h.client.Get(bufferQuery.String(), extraHeaders)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// HTTPSplitFetcher struct is responsible for fetching splits from the backend via HTTP protocol
+type HTTPSplitFetcher struct {
+	httpFetcherBase
+}
+
+// NewHTTPSplitFetcher instantiates and return an HTTPSplitFetcher
+func NewHTTPSplitFetcher(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	logger logging.LoggerInterface,
+	metadata dtos.Metadata,
+) *HTTPSplitFetcher {
+	return &HTTPSplitFetcher{
+		httpFetcherBase: httpFetcherBase{
+			client: NewHTTPClient(apikey, cfg, cfg.SdkURL, logger, metadata),
+			logger: logger,
+		},
+	}
+}
+
+// Fetch makes an http call to the split backend and returns the list of updated splits
+func (f *HTTPSplitFetcher) Fetch(since int64, requestNoCache bool) (*dtos.SplitChangesDTO, error) {
+	data, err := f.fetchRaw("/splitChanges", since, requestNoCache)
+	if err != nil {
+		f.logger.Error("Error fetching split changes ", err)
+		return nil, err
+	}
+
+	var splitChangesDto dtos.SplitChangesDTO
+	err = json.Unmarshal(data, &splitChangesDto)
+	if err != nil {
+		f.logger.Error("Error parsing split changes JSON ", err)
+		return nil, err
+	}
+
+	return &splitChangesDto, nil
+}
+
+// HTTPSegmentFetcher struct is responsible for fetching segment by name from the API via HTTP method
+type HTTPSegmentFetcher struct {
+	httpFetcherBase
+}
+
+// NewHTTPSegmentFetcher instantiates and returns a new HTTPSegmentFetcher.
+func NewHTTPSegmentFetcher(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	logger logging.LoggerInterface,
+	metadata dtos.Metadata,
+) *HTTPSegmentFetcher {
+	return &HTTPSegmentFetcher{
+		httpFetcherBase: httpFetcherBase{
+			client: NewHTTPClient(apikey, cfg, cfg.SdkURL, logger, metadata),
+			logger: logger,
+		},
+	}
+}
+
+// Fetch issues a GET request to the split backend and returns the contents of a particular segment
+func (f *HTTPSegmentFetcher) Fetch(segmentName string, since int64, requestNoCache bool) (*dtos.SegmentChangesDTO, error) {
+	var bufferQuery bytes.Buffer
+	bufferQuery.WriteString("/segmentChanges/")
+	bufferQuery.WriteString(segmentName)
+
+	data, err := f.fetchRaw(bufferQuery.String(), since, requestNoCache)
+	if err != nil {
+		f.logger.Error(err.Error())
+		return nil, err
+	}
+	var segmentChangesDto dtos.SegmentChangesDTO
+	err = json.Unmarshal(data, &segmentChangesDto)
+	if err != nil {
+		f.logger.Error("Error parsing segment changes JSON for segment ", segmentName, err)
+		return nil, err
+	}
+
+	return &segmentChangesDto, nil
+}

vendor/github.com/splitio/go-split-commons/v3/service/api/http_recorders.go

@@ -0,0 +1,197 @@
+package api
+
+import (
+	"encoding/json"
+
+	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-split-commons/v3/dtos"
+	"github.com/splitio/go-toolkit/v4/logging"
+)
+
+type httpRecorderBase struct {
+	client Client
+	logger logging.LoggerInterface
+}
+
+// RecordRaw records raw data
+func (h *httpRecorderBase) RecordRaw(url string, data []byte, metadata dtos.Metadata, extraHeaders map[string]string) error {
+	headers := make(map[string]string)
+	headers["SplitSDKVersion"] = metadata.SDKVersion
+	if metadata.MachineName != "NA" && metadata.MachineName != "unknown" {
+		headers["SplitSDKMachineName"] = metadata.MachineName
+	}
+	if metadata.MachineIP != "NA" && metadata.MachineIP != "unknown" {
+		headers["SplitSDKMachineIP"] = metadata.MachineIP
+	}
+	if extraHeaders != nil {
+		for header, value := range extraHeaders {
+			headers[header] = value
+		}
+	}
+	return h.client.Post(url, data, headers)
+}
+
+// HTTPImpressionRecorder is a struct responsible for submitting impression bulks to the backend
+type HTTPImpressionRecorder struct {
+	httpRecorderBase
+}
+
+// Record sends an array (or slice) of impressionsRecord to the backend
+func (i *HTTPImpressionRecorder) Record(impressions []dtos.ImpressionsDTO, metadata dtos.Metadata, extraHeaders map[string]string) error {
+	data, err := json.Marshal(impressions)
+	if err != nil {
+		i.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = i.RecordRaw("/testImpressions/bulk", data, metadata, extraHeaders)
+	if err != nil {
+		i.logger.Error("Error posting impressions", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// RecordImpressionsCount sens impressionsCount
+func (i *HTTPImpressionRecorder) RecordImpressionsCount(pf dtos.ImpressionsCountDTO, metadata dtos.Metadata) error {
+	if len(pf.PerFeature) == 0 {
+		return nil
+	}
+	data, err := json.Marshal(pf)
+	if err != nil {
+		i.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = i.RecordRaw("/testImpressions/count", data, metadata, nil)
+	if err != nil {
+		i.logger.Error("Error posting impressionsCount", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// NewHTTPImpressionRecorder instantiates an HTTPImpressionRecorder
+func NewHTTPImpressionRecorder(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	logger logging.LoggerInterface,
+) *HTTPImpressionRecorder {
+	client := NewHTTPClient(apikey, cfg, cfg.EventsURL, logger, dtos.Metadata{})
+	return &HTTPImpressionRecorder{
+		httpRecorderBase: httpRecorderBase{
+			client: client,
+			logger: logger,
+		},
+	}
+}
+
+// HTTPMetricsRecorder is a struct responsible for submitting metrics (latency, gauge, counters) to the backend
+type HTTPMetricsRecorder struct {
+	httpRecorderBase
+}
+
+// RecordCounters method submits counter metrics to the backend
+func (m *HTTPMetricsRecorder) RecordCounters(counters []dtos.CounterDTO, metadata dtos.Metadata) error {
+	data, err := json.Marshal(counters)
+	if err != nil {
+		m.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = m.RecordRaw("/metrics/counters", data, metadata, nil)
+	if err != nil {
+		m.logger.Error("Error posting counters", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// RecordLatencies method submits latency metrics to the backend
+func (m *HTTPMetricsRecorder) RecordLatencies(latencies []dtos.LatenciesDTO, metadata dtos.Metadata) error {
+	data, err := json.Marshal(latencies)
+	if err != nil {
+		m.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = m.RecordRaw("/metrics/times", data, metadata, nil)
+	if err != nil {
+		m.logger.Error("Error posting latencies", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// RecordGauge method submits gauge metrics to the backend
+func (m *HTTPMetricsRecorder) RecordGauge(gauge dtos.GaugeDTO, metadata dtos.Metadata) error {
+	data, err := json.Marshal(gauge)
+	if err != nil {
+		m.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = m.RecordRaw("/metrics/gauge", data, metadata, nil)
+	if err != nil {
+		m.logger.Error("Error posting gauges", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// NewHTTPMetricsRecorder instantiates an HTTPMetricsRecorder
+func NewHTTPMetricsRecorder(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	logger logging.LoggerInterface,
+) *HTTPMetricsRecorder {
+	client := NewHTTPClient(apikey, cfg, cfg.EventsURL, logger, dtos.Metadata{})
+	return &HTTPMetricsRecorder{
+		httpRecorderBase: httpRecorderBase{
+			client: client,
+			logger: logger,
+		},
+	}
+}
+
+// HTTPEventsRecorder is a struct responsible for submitting events bulks to the backend
+type HTTPEventsRecorder struct {
+	httpRecorderBase
+}
+
+// Record sends an array (or slice) of dtos.EventDTO to the backend
+func (i *HTTPEventsRecorder) Record(events []dtos.EventDTO, metadata dtos.Metadata) error {
+	data, err := json.Marshal(events)
+	if err != nil {
+		i.logger.Error("Error marshaling JSON", err.Error())
+		return err
+	}
+
+	err = i.RecordRaw("/events/bulk", data, metadata, nil)
+	if err != nil {
+		i.logger.Error("Error posting events", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+// NewHTTPEventsRecorder instantiates an HTTPEventsRecorder
+func NewHTTPEventsRecorder(
+	apikey string,
+	cfg conf.AdvancedConfig,
+	logger logging.LoggerInterface,
+) *HTTPEventsRecorder {
+	client := NewHTTPClient(apikey, cfg, cfg.EventsURL, logger, dtos.Metadata{})
+	return &HTTPEventsRecorder{
+		httpRecorderBase: httpRecorderBase{
+			client: client,
+			logger: logger,
+		},
+	}
+}

vendor/github.com/splitio/go-split-commons/v3/service/api/sse/client.go

@@ -0,0 +1,123 @@
+package sse
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-toolkit/v4/logging"
+	"github.com/splitio/go-toolkit/v4/sse"
+	"github.com/splitio/go-toolkit/v4/struct/traits/lifecycle"
+	gtSync "github.com/splitio/go-toolkit/v4/sync"
+)
+
+const (
+	version   = "1.1"
+	keepAlive = 70
+)
+
+// StreamingClient interface
+type StreamingClient interface {
+	ConnectStreaming(token string, streamingStatus chan int, channelList []string, handleIncomingMessage func(IncomingMessage))
+	StopStreaming()
+	IsRunning() bool
+}
+
+// StreamingClientImpl struct
+type StreamingClientImpl struct {
+	sseClient *sse.Client
+	logger    logging.LoggerInterface
+	lifecycle lifecycle.Manager
+}
+
+// Status constants
+const (
+	StatusConnectionFailed = iota
+	StatusUnderlyingClientInUse
+	StatusFirstEventOk
+	StatusDisconnected
+)
+
+// IncomingMessage is an alias of sse.RawEvent
+type IncomingMessage = sse.RawEvent
+
+// NewStreamingClient creates new SSE Client
+func NewStreamingClient(cfg *conf.AdvancedConfig, logger logging.LoggerInterface) *StreamingClientImpl {
+	sseClient, _ := sse.NewClient(cfg.StreamingServiceURL, keepAlive, logger)
+
+	client := &StreamingClientImpl{
+		sseClient: sseClient,
+		logger:    logger,
+	}
+	client.lifecycle.Setup()
+	return client
+}
+
+// ConnectStreaming connects to streaming
+func (s *StreamingClientImpl) ConnectStreaming(token string, streamingStatus chan int, channelList []string, handleIncomingMessage func(IncomingMessage)) {
+
+	if !s.lifecycle.BeginInitialization() {
+		s.logger.Info("Connection is already in process/running. Ignoring")
+		return
+	}
+
+	params := make(map[string]string)
+	params["channels"] = strings.Join(append(channelList), ",")
+	params["accessToken"] = token
+	params["v"] = version
+
+	go func() {
+		defer s.lifecycle.ShutdownComplete()
+		if !s.lifecycle.InitializationComplete() {
+			return
+		}
+		firstEventReceived := gtSync.NewAtomicBool(false)
+		out := s.sseClient.Do(params, func(m IncomingMessage) {
+			if firstEventReceived.TestAndSet() && !m.IsError() {
+				streamingStatus <- StatusFirstEventOk
+			}
+			handleIncomingMessage(m)
+		})
+
+		if out == nil { // all good
+			streamingStatus <- StatusDisconnected
+			return
+		}
+
+		// Something didn'g go as expected
+		s.lifecycle.AbnormalShutdown()
+
+		asConnectionFailedError := &sse.ErrConnectionFailed{}
+		if errors.As(out, &asConnectionFailedError) {
+			streamingStatus <- StatusConnectionFailed
+			return
+		}
+
+		switch out {
+		case sse.ErrNotIdle:
+			// If this happens we have a bug
+			streamingStatus <- StatusUnderlyingClientInUse
+		case sse.ErrReadingStream:
+			streamingStatus <- StatusDisconnected
+		case sse.ErrTimeout:
+			streamingStatus <- StatusDisconnected
+		default:
+		}
+	}()
+}
+
+// StopStreaming stops streaming
+func (s *StreamingClientImpl) StopStreaming() {
+	if !s.lifecycle.BeginShutdown() {
+		s.logger.Info("SSE client wrapper not running. Ignoring")
+		return
+	}
+	s.sseClient.Shutdown(true)
+	s.lifecycle.AwaitShutdownComplete()
+	s.logger.Info("Stopped streaming")
+}
+
+// IsRunning returns true if the client is running
+func (s *StreamingClientImpl) IsRunning() bool {
+	return s.lifecycle.IsRunning()
+}