SDK de Go

go get github.com/Kameleoon/client-go/v3

import (
	kameleoon "github.com/Kameleoon/client-go/v3"
)

// First option
config := &kameleoon.KameleoonClientConfig{
	Network: kameleoon.NetworkConfig{ // Optional
		ProxyURL:        "http://proxy-pass:1234/", // Optional
		DoTimeout:       10 * time.Second, // Optional
		ReadTimeout:     5 * time.Second, // Optional
		WriteTimeout:    5 * time.Second, // Optional
		MaxConnsPerHost: 10000, // Optional
	},
	ClientID:         "your-client-id", // Este campo es obligatorio. Please enter your client_id here.
	ClientSecret:     "your-client-secret", // Este campo es obligatorio. Please enter your client_secret here.
	TopLevelDomain:   "example.com", // This field is strictly recommended, otherwise you may have problems when using subdomains.
	RefreshInterval:  time.Hour, // Optional (60 minutes by default)
	TrackingInterval: time.Second, // Optional (1000 ms by default)
	Environment:      "staging", // Optional
	SessionDuration:  30 * time.Minute, // Optional (30 minutes by default)
    NetworkDomain:    "example.com", // Optional
}
client, err := KameleoonClientFactory.Create("your-project-sitecode", config)

// Second option
config, err := LoadConfig("/etc/kameleoon/client-go.yaml")
client, err := KameleoonClientFactory.Create("your-project-sitecode", config)
// Notice: In the example above, the configuration is loaded every time. To load it once, use `CreateFromFile`.

// Third option
client, err := KameleoonClientFactory.CreateFromFile("your-project-sitecode", "/etc/kameleoon/client-go.yaml")

// In this example, `91` represents the Custom Data's index
// configured as a unique identifier in Kameleoon.
const MappingIndex = 91
const FeatureKey = "ff123"

// 1. Before the visitor is authenticated

// Retrieve the variation for an unauthenticated visitor.
// Assume `anonymousVisitorCode` is the randomly generated ID for that visitor.
anonymousVariation, err := kameleoonClient.GetVariation(anonymousVisitorCode, FeatureKey)

// 2. After the visitor is authenticated

// Assume `userId` is the authenticated visitor's visitor code.
kameleoonClient.AddData(anonymousVisitorCode, types.NewCustomData(MappingIndex, userId))
err := kameleoonClient.FlushVisitorInstantly(anonymousVisitorCode)

// Indicate that `userId` is a unique identifier.
kameleoonClient.AddData(userId, types.NewUniqueIdentifier(true))

// 3. After the visitor has been authenticated

// Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
userVariation, err := kameleoonClient.GetVariation(userId, FeatureKey)
isSameVariation := userVariation.Key == anonymousVariation.Key // true

// The `userId` and `anonymousVisitorCode` are now linked and tracked as a single visitor.
err := kameleoonClient.TrackConversionRevenue(userId, 123, 10.0)

// Additionally, the linked visitors will share all fetched remote visitor data.
_, err := kameleoonClient.GetRemoteVisitorData(userId, true)

client.AddData(visitorCode, types.NewCustomData(index, "newVisitorCode"))

import (
	"development.kameleoon.net/sdk/go-sdk/v3/logging"
)

// The `NONE` log level does not allow logging.
logging.SetLogLevel(logging.NONE)

// The `ERROR` log level only allows logging issues that may affect the SDK's primary behavior.
logging.SetLogLevel(logging.ERROR)

// The `WARNING` log level allows logging issues which may require additional attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
logging.SetLogLevel(logging.WARNING)

//The `INFO` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
logging.SetLogLevel(logging.INFO)

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
logging.SetLogLevel(logging.DEBUG)

import (
    "development.kameleoon.net/sdk/go-sdk/v3/logging"
    "github.com/sirupsen/logrus"
)

type CustomLogger struct {
}

func NewCustomLogger() logging.LoggerWithLevel {
    return &CustomLogger{}
}

func (dl CustomLogger) Log(level logging.LogLevel, message string) {
    switch level {
    case logging.NONE:
    case logging.ERROR:
        logrus.Error(message)
    case logging.WARNING:
        logrus.Warn(message)
    case logging.INFO:
        logrus.Info(message)
    case logging.DEBUG:
        logrus.Debug(message)
    }
}


// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
logging.SetLogLevel(logging.DEBUG) // Optional; defaults to `logging.WARNING`.
logging.SetLogger(NewCustomLogger())

const siteCode = "sitecode"
config := &kameleoon.KameleoonClientConfig{
	// ...
}

client, err := KameleoonClientFactory.Create(siteCode, config)

const siteCode = "sitecode"
client, err := KameleoonClientFactory.CreateFromFile(siteCode, "/etc/kameleoon/client-go.yaml")

const siteCode = "sitecode"
KameleoonClientFactory.Forget(siteCode)

// Waits up to the default timeout of the client configuration
err := client.WaitInit()

// Waits no longer than the specified timeout
err = client.WaitInit(1 * time.Second)

if err != nil {
	// Client wasn't initialized properly
	fmt.Println(err)
} else {
	// The SDK has been initialized; you can fetch a feature flag / experiment configuration here.
}

ready := client.IsReady()

const featureKey = "new_checkout"

// Check if a Feature Flag is active (ON / OFF)
hasNewCheckout, err := client.IsFeatureActive(visitorCode, featureKey)
// disabling tracking
hasNewCheckout, err := client.IsFeatureActiveWithTracking(visitorCode, featureKey, false)

if err != nil {
	switch err.(type) {
	case *errs.VisitorCodeInvalid:
		// The provided visitor code is not valid. Trigger the old checkout for this visitor.
		hasNewCheckout = false
	case *errs.FeatureConfigNotFound:
		// The Feature Key is not yet in the configuration file that has been fetched by the SDK. Trigger the old checkout for this visitor.
		hasNewCheckout = false
	default:
		// Handle unexpected errors
		panic(err)
	}
}
if hasNewCheckout {
	// Implement new checkout code here
}

const featureKey = "new_checkout"

variation, err := client.GetVariation(visitorCode, featureKey)
// disabling tracking
variation, err := client.GetVariation(visitorCode, featureKey, NewGetVariationOptParams().Track(false))

if err != nil {
	// handle error
}

// Fetch a variable value for the assigned variation
title := variation.Variables["title"].Value

switch (variation.Key) {
	case "on":
		// Main variation key is selected for visitorCode
	case "alternative_variation":
		// Alternative variation key
	default:
		// Default variation key
}

variations, err := client.GetVariations(visitorCode)
// all active variations
variations, err := client.GetVariations(visitorCode, NewGetVariationsOptParams().OnlyActive(true))
// disable tracking
variations, err := client.GetVariations(visitorCode, NewGetVariationsOptParams().Track(false))

if err != nil {
	// handle error
}

const experimentId = 9516

// Forcing the variation "on" in the experiment 9516 for the visitor.
err := client.SetForcedVariation(visitorCode, experimentId, "on")

// Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment.
err := client.SetForcedVariation(
    visitorCode, experimentId, "on", NewSetForcedVariationOptParams().ForceTargeting(false),
)

// Resetting the forced variation in the experiment 9516 for the visitor.
err := client.SetForcedVariation(visitorCode, experimentId, "")

if err != nil {
    // Handling the error
}

if err := client.EvaluateAudiences(visitorCode); err != nil {
    // Handling the error
}

dataFile := client.GetDataFile()

visitorCode, err := client.GetVisitorCode(req, resp)

visitorCode, err := client.GetVisitorCode(req, resp, "defaultVisitorCode")

import (
	"github.com/Kameleoon/client-go/v3/types"
)
// Add a single data item (tracked by default)
client.AddData(visitorCode, types.NewBrowser(types.BrowserTypeChrome))

// Add multiple data items (tracked by default)
client.AddData(visitorCode,
    types.NewPageViewWithTitle("https://url.com", "title", 3),
    types.UserAgent("UserAgent"),
)

// Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
client.AddDataWithOptParams(
    visitorCode,
    NewAddDataOptParams().Track(false),
    types.NewPageViewWithTitle("https://url.com", "title", 3),
    types.UserAgent("UserAgent")
)

import (
	"github.com/Kameleoon/client-go/v3/types"
)

visitorCode, err := client.GetVisitorCode(req, resp)

client.AddData(visitorCode, types.NewBrowser(types.BrowserTypeChrome))
client.AddData(visitorCode, types.NewConversionWithRevenue(32, 10, false))

client.FlushVisitor(visitorCode) // Interval tracking (most performant tracking method)
client.FlushAll() // Interval tracking for all visitors' unsent data

client.FlushVisitorInstantly(visitorCode) // Instant tracking
client.FlushAll(true) // Instant tracking for all visitors' unsent data

// if you operate with a unique ID
client.AddData(types.NewUniqueIdentifier(true))
client.FlushVisitor(visitorCode)

type Test1 struct {
	Value string `json:"some field to insert or update"`
}

remoteData, err := s.client.GetRemoteData("USER_ID") // uses default timeout
var test1 Test1
err = json.Unmarshal(remoteData, &test1)

remoteData, err := s.client.GetRemoteData("USER_ID", 1000)

//Retrieve and use Mixpanel Cohorts
type Cohort struct {
	Id        string `json:"mixpanel_cohort_id"`
	Name      string `json:"mixpanel_cohort_name"`
	ProjectId string `json:"mixpanel_cohort_project_id"`
}

type MixPanelCohorts struct {
	Cohorts []Cohort `json:"mixpanel_cohorts"`
}

remoteData, err := s.client.GetRemoteData("USER_ID")
var mixPanel MixPanelCohorts
if err = json.Unmarshal(remoteData, &mixPanel); err == nil {
	cohorts := make([]string, len(mixPanel.Cohorts))
	for _, cohort := range mixPanel.Cohorts {
		cohorts = append(cohorts, cohort.Id)
	}
	client.AddData(visitorCode, types.NewCustomData(customDataIndex, cohorts...))
}

visitorCode := "visitorCode"
var visitorData []types.Data
var err error

// Visitor data will be fetched and automatically added for `visitorCode`
visitorData, err = client.GetRemoteVisitorData(visitorCode, true) // default timeout will be used
visitorData, err = client.GetRemoteVisitorData(visitorCode, true, time.Second) // 1000 milliseconds timeout

// If you only want to fetch data and add it yourself manually, set `addData` to `false`.
visitorData, err = client.GetRemoteVisitorData(visitorCode, false) // default timeout will be used
visitorData, err = client.GetRemoteVisitorData(visitorCode, false, time.Second) // 1000 milliseconds timeout

// If you operate with a unique ID
client.AddData(types.NewUniqueIdentifier(true))
visitorData, err = client.GetRemoteVisitorData(visitorCode, true)

// If you want to fetch a custom list of data types
var visitorData = client.GetRemoteVisitorDataWithFilter(
    visitorCode,
    true,
    types.RemoteVisitorDataFilter{PreviousVisitAmount: 10, CustomData: true, Conversion: true, Experiments: true},
    // default timeout will be used
)
// or
var visitorData = client.GetRemoteVisitorDataWithFilter(
    visitorCode,
    true,
    types.RemoteVisitorDataFilter{PreviousVisitAmount: 10, CustomData: true, Conversion: true, Experiments: true},
    time.Second, // 1000 milliseconds timeout
)

customData, err = client.GetVisitorWarehouseAudience(VisitorWarehouseAudienceParams{
    VisitorCode:     "visitorCode",
    CustomDataIndex: 10,
    WarehouseKey:    "warehouseKey", // optional
    Timeout:         5 * time.Second, // optional
})

customData, err = c.GetVisitorWarehouseAudienceWithOptParams(
    "visitorCode", 10, VisitorWarehouseAudienceOptParams{WarehouseKey: "warehouseKey", Timeout: 5 * time.Second})

visitorCode, err := kameleoonClient.GetVisitorCode(req, resp)

err := kameleoonClient.SetLegalConsent(visitorCode, true, resp)

import (
	"github.com/Kameleoon/client-go/v3/types"
)

const goalID = 83023

client.TrackConversion(visitorCode, goalID)

client.TrackConversionRevenue(visitorCode, goalID, 10.0)

// Add metadata
client.TrackConversionWithOptParams(visitorCode, goalID, TrackConversionOptParams{
    Metadata: []*types.CustomData{
        types.NewCustomData(3, "metadata1", "md2"),
        types.NewCustomData(5, "md3")
    },
})

engineTrackingCode := kameleoonClient.GetEngineTrackingCode(visitorCode)

client.AddData(visitorCode, types.NewBrowser(types.BrowserTypeChrome))

client.AddData(visitorCode, types.NewBrowser(types.BrowserTypeSafari, 16.0))

client.AddData(visitorCode, types.NewConversion(32, true))

client.AddData(visitorCode, types.NewConversionWithRevenue(33, 10.0, false))

client.AddData(
    visitorCode,
    types.NewConversionWithOptParams(34, types.ConversionOptParams{
        Revenue: 5.0,
        Metadata: []*types.CustomData{
            types.NewCustomData(3, "metadata1", "md2"),
            types.NewCustomData(5, "md3"),
        },
    }),
)

client.AddData(visitorCode, types.NewConversion(32, false))

client.AddData(visitorCode, types.NewConversionWithRevenue(32, 10, false))

cookie := types.NewCookie(map[string]string{
  "k1": "v1",
  "k2": "v2",
})
client.AddData(visitorCode, cookie)

client.AddData(visitorCode, types.NewGeolocation("France", "Île-de-France", "Paris"))

client.AddData(visitorCode, types.NewGeolocationWithCoords(48.856667, 2.352222, "France", "Île-de-France", "Paris"))

client.AddData(visitorCode, types.NewCustomData(1, "value"))

// With several values
client.AddData(visitorCode, types.NewCustomData(1, "value1", "value2"))

// To set the 'overwrite' flag to false
client.AddData(
    visitorCode,
    types.NewCustomDataWithOptParams(1, NewCustomDataOptParams().Overwrite(false), "value"),
)

// To use a name instead of the index
client.AddData(visitorCode, types.NewNamedCustomData("my-custom-data", "value"))

// To use a name instead of the index
// and set the 'overwrite' flag to false
client.AddData(
    visitorCode,
    types.NewNamedCustomDataWithOptParams("my-custom-data", NewCustomDataOptParams().Overwrite(false), "value"),
)

client.AddData(visitorCode, types.NewDevice(types.DeviceTypeDesktop))

client.AddData(visitorCode, types.NewOperatingSystem(types.OperatingSystemTypeWindows))

client.AddData(visitorCode, types.NewPageView("https://url.com", 3))

client.AddData(visitorCode, types.NewPageViewWithTitle("https://url.com", "title", 3))

client.AddData(visitorCode, types.NewUserAgent("visitor_user_agent"))

client.AddData(visitorCode, types.NewUniqueIdentifier(true))

client.AddData(visitorCode, types.NewApplicationVersion("10")) // major

client.AddData(visitorCode, types.NewApplicationVersion("10.20")) // major.minor

client.AddData(visitorCode, types.NewApplicationVersion("10.20.30")) // major.minor.patch

// Retrieves the map of feature flags from the DataFile.
// The map is keyed by feature flag identifiers, with each value being a FeatureFlag object.
featureFlags := dataFile.FeatureFlags

// Retrieves the last modification timestamp of the DataFile.
// The value is an int64 representing milliseconds since the Unix epoch.
dateModified := dataFile.DateModified

// Check whether the feature flag is enabled in the current environment
isEnvironmentEnabled := featureFlag.IsEnvironmentEnabled

// Retrieve the key of the default variation
defaultVariationKey = featureFlag.DefaultVariationKey

// Retrieve the default variation object
defaultVariation := featureFlag.DefaultVariation()

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object)
variations := featureFlag.Variations

// Retrieve all targeting rules associated with the feature flag
rules := featureFlag.Rules

// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
variations := rule.Variations

// Retrieving the variation name
var variationName string = variation.Name

// Retrieving the variation key
var variationKey string = variation.Key

// Retrieving the variation id
var variationID *int = variation.VariationID

// Retrieving the experiment id
var experimentID *int = variation.ExperimentID

// Retrieving the variables map
var variables map[string]Variable = variation.Variables

// Retrieving the variables map
var variables map[string]Variable = variation.Variables

// Variable type can be retrieved for further processing
var variableType string = variables["isDiscount"].Type

// Retrieving the variable value by key
var isDiscount bool = variables["isDiscount"].Value.(bool)

// Variable value can be of different types
var title string = variables["title"].Value.(string)

// Feature Experiment with variations
const variationKey = ""

if variationKey, err := s.client.GetFeatureVariationKey(visitorCode, featureKey); err == nil {
	switch variationKey {
	case "variation 1":
		// The visitor has been bucketed with variation 1 key.
	case "variation 2":
		// The visitor has been bucketed with variation 2 key.
	default:
		//The visitor has been bucketed with the default variation or is part of the unallocated traffic sample.
	}
} else {
	// An error occurred; the feature flag key has not been found in the current configuration fetched by the SDK.
}

arrayFeatureFlagKeys, err := client.GetActiveFeatureListForVisitor(visitorCode)

activeFeatures, err := client.GetActiveFeatures(visitorCode)

visitorCode, err := client.GetVisitorCode(req, resp)
featureKey := "featureKey"
variableKey = "variableKey"

if variableValue, err := s.client.GetFeatureVariable(visitorCode, featureKey, variableKey); err == nil {
	// your custom code depending of variableValue
} else {
	// An error occurred; the feature flag has not been found in the current configuration fetched by the SDK.
}