Recipes
Go SDK

5min
1. use amberflo api-key
Go
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
﻿
2. setup the metering client
Go
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)
﻿
3. ingest meters
Go
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)

	//Define dimesions for your meters. Dimensions can be used as filters.
	dimensions := make(map[string]string)
	dimensions["region"] = "Midwest"
	dimensions["customerType"] = "Tech"

	for i := 0; i < 50; i++ {
		utcMillis := time.Now().UnixNano() / int64(time.Millisecond)
		//Queue meter messages for ingestion.
		//Queue will be flushed asyncrhonously when Metering.BatchSize is exceeded
		//or periodically at Metering.IntervalSeconds
		//unique ID is optional, but setting it
		//helps with de-dupe and revoking an ingested meter
		uniqueId := uuid.NewRandom().String()
		meteringError := meteringClient.Meter(&metering.MeterMessage{
			UniqueId:          uniqueId,
			MeterApiName:      "ApiCalls-From-Go",
			CustomerId:        "1234",
			MeterValue:        float64(i) + 234.0,
			MeterTimeInMillis: utcMillis,
			Dimensions:        dimensions,
		})
		if meteringError != nil {
			fmt.Println("Metering error: ", meteringError)
		}
		time.Sleep(500 * time.Millisecond)
	}
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)

	//Define dimesions for your meters. Dimensions can be used as filters.
	dimensions := make(map[string]string)
	dimensions["region"] = "Midwest"
	dimensions["customerType"] = "Tech"

	for i := 0; i < 50; i++ {
		utcMillis := time.Now().UnixNano() / int64(time.Millisecond)
		//Queue meter messages for ingestion.
		//Queue will be flushed asyncrhonously when Metering.BatchSize is exceeded
		//or periodically at Metering.IntervalSeconds
		//unique ID is optional, but setting it
		//helps with de-dupe and revoking an ingested meter
		uniqueId := uuid.NewRandom().String()
		meteringError := meteringClient.Meter(&metering.MeterMessage{
			UniqueId:          uniqueId,
			MeterApiName:      "ApiCalls-From-Go",
			CustomerId:        "1234",
			MeterValue:        float64(i) + 234.0,
			MeterTimeInMillis: utcMillis,
			Dimensions:        dimensions,
		})
		if meteringError != nil {
			fmt.Println("Metering error: ", meteringError)
		}
		time.Sleep(500 * time.Millisecond)
	}
﻿
4. shutdown metering client
Go
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)

	//Define dimesions for your meters. Dimensions can be used as filters.
	dimensions := make(map[string]string)
	dimensions["region"] = "Midwest"
	dimensions["customerType"] = "Tech"

	for i := 0; i < 50; i++ {
		utcMillis := time.Now().UnixNano() / int64(time.Millisecond)
		//Queue meter messages for ingestion.
		//Queue will be flushed asyncrhonously when Metering.BatchSize is exceeded
		//or periodically at Metering.IntervalSeconds
		//unique ID is optional, but setting it
		//helps with de-dupe and revoking an ingested meter
		uniqueId := uuid.NewRandom().String()
		meteringError := meteringClient.Meter(&metering.MeterMessage{
			UniqueId:          uniqueId,
			MeterApiName:      "ApiCalls-From-Go",
			CustomerId:        "1234",
			MeterValue:        float64(i) + 234.0,
			MeterTimeInMillis: utcMillis,
			Dimensions:        dimensions,
		})
		if meteringError != nil {
			fmt.Println("Metering error: ", meteringError)
		}
		time.Sleep(500 * time.Millisecond)
	}

	//Perform graceful shutdown
	//Flush all messages in the queue, stop the timer, close all channels, and shutdown the client
	meteringClient.Shutdown()
}
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/amberflo/metering-go/v2"
	"github.com/rs/zerolog"
	"github.com/xtgo/uuid"
)

func main() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
  
	//Optional ingest options
	//Frequency at which queued data will be sent to API. Default is 1 second.
	intervalSeconds := 30 * time.Second
	//Number of messages posted to the API. Default is 100.
	batchSize := 5
	//Debug mode logging. Default is false.
	debug := true

	//Instantiate a new metering client
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithBatchSize(batchSize),
		metering.WithIntervalSeconds(intervalSeconds),
		metering.WithDebug(debug),
	)

	//Define dimesions for your meters. Dimensions can be used as filters.
	dimensions := make(map[string]string)
	dimensions["region"] = "Midwest"
	dimensions["customerType"] = "Tech"

	for i := 0; i < 50; i++ {
		utcMillis := time.Now().UnixNano() / int64(time.Millisecond)
		//Queue meter messages for ingestion.
		//Queue will be flushed asyncrhonously when Metering.BatchSize is exceeded
		//or periodically at Metering.IntervalSeconds
		//unique ID is optional, but setting it
		//helps with de-dupe and revoking an ingested meter
		uniqueId := uuid.NewRandom().String()
		meteringError := meteringClient.Meter(&metering.MeterMessage{
			UniqueId:          uniqueId,
			MeterApiName:      "ApiCalls-From-Go",
			CustomerId:        "1234",
			MeterValue:        float64(i) + 234.0,
			MeterTimeInMillis: utcMillis,
			Dimensions:        dimensions,
		})
		if meteringError != nil {
			fmt.Println("Metering error: ", meteringError)
		}
		time.Sleep(500 * time.Millisecond)
	}

	//Perform graceful shutdown
	//Flush all messages in the queue, stop the timer, close all channels, and shutdown the client
	meteringClient.Shutdown()
}
﻿
5. query usage
Go
func usage() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"

	//initialize the usage client
	usageClient := metering.NewUsageClient(apiKey)
    
  //set the start time of the time range in Epoch seconds
  startTimeInSeconds := (time.Now().UnixNano() / int64(time.Second)) - (24 * 60 * 60)
	timeRange := &metering.TimeRange{
		StartTimeInSeconds: startTimeInSeconds,
	}
  
  //specify the limit and sort order
	take := &metering.Take{
		Limit:       10,
		IsAscending: true,
	}

	// Example 1: group by customers for a specific meter and all customers
	// setup usage query params
	// visit following link for description of payload:
	// https://amberflo.readme.io/reference#usage
	usageResult, err := usageClient.GetUsage(&metering.UsagePayload{
		MeterApiName:         "ApiCalls-From-Go",
		Aggregation:          metering.Sum,
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"customerId"},
		TimeRange:            timeRange,
	})
	fmt.Println("Usage by meterApiName in json format")
	printUsageData(*usageResult, err)

	//Example 2: filter for a meter for specific customer
	//setup usage query params
	filter := make(map[string]string)
	filter["customerId"] = "1234"

	usageResult, err = usageClient.GetUsage(&metering.UsagePayload{
		MeterApiName:         "ApiCalls-From-Go",
		Aggregation:          metering.Sum,
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"customerId"},
		TimeRange:            timeRange,
		Filter:               filter,
	})
	fmt.Println("Usage for meter for specific customer in json format")
	printUsageData(*usageResult, err)
}

func printUsageData(usageResult metering.DetailedMeterAggregation, err error) {
	if err != nil {
		fmt.Println("Usage error: ", err)
		return
	}

	jsonString, err := json.MarshalIndent(usageResult, "", "  ")
	if err != nil {
		fmt.Println("Usage error: ", err)
		return
	}

	fmt.Println(string(jsonString))
}
func usage() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"

	//initialize the usage client
	usageClient := metering.NewUsageClient(apiKey)
    
  //set the start time of the time range in Epoch seconds
  startTimeInSeconds := (time.Now().UnixNano() / int64(time.Second)) - (24 * 60 * 60)
	timeRange := &metering.TimeRange{
		StartTimeInSeconds: startTimeInSeconds,
	}
  
  //specify the limit and sort order
	take := &metering.Take{
		Limit:       10,
		IsAscending: true,
	}

	// Example 1: group by customers for a specific meter and all customers
	// setup usage query params
	// visit following link for description of payload:
	// https://amberflo.readme.io/reference#usage
	usageResult, err := usageClient.GetUsage(&metering.UsagePayload{
		MeterApiName:         "ApiCalls-From-Go",
		Aggregation:          metering.Sum,
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"customerId"},
		TimeRange:            timeRange,
	})
	fmt.Println("Usage by meterApiName in json format")
	printUsageData(*usageResult, err)

	//Example 2: filter for a meter for specific customer
	//setup usage query params
	filter := make(map[string]string)
	filter["customerId"] = "1234"

	usageResult, err = usageClient.GetUsage(&metering.UsagePayload{
		MeterApiName:         "ApiCalls-From-Go",
		Aggregation:          metering.Sum,
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"customerId"},
		TimeRange:            timeRange,
		Filter:               filter,
	})
	fmt.Println("Usage for meter for specific customer in json format")
	printUsageData(*usageResult, err)
}

func printUsageData(usageResult metering.DetailedMeterAggregation, err error) {
	if err != nil {
		fmt.Println("Usage error: ", err)
		return
	}

	jsonString, err := json.MarshalIndent(usageResult, "", "  ")
	if err != nil {
		fmt.Println("Usage error: ", err)
		return
	}

	fmt.Println(string(jsonString))
}
﻿
6. create customer
Go
func setupCustomer() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
	customerId := "dell-8"
	//Automatically create customer in Stripe
	//and add stripeId to traits
	createCustomerInStripe := true

	//Instantiate a new metering client
	customerClient := metering.NewCustomerClient(apiKey)

	//check if customer exists
	customer, err := customerClient.GetCustomer(customerId)
	if err != nil {
		fmt.Println("Error getting customer details: ", err)
	}

	//setup customer
	//Traits are optional. Traits can be used as filters or aggregation buckets.
	if customer != nil {
		//customer exists
		//update properties
		customer.CustomerName = "Dell 2"
	} else {
		//setup new customer
		//Traits are optional. Traits can be used as filters or aggregation buckets.
		traits := make(map[string]string)
		traits["region"] = "us-west"
		traits["customerType"] = "Tech"
		customer = &metering.Customer{
			CustomerId:    customerId,
			CustomerName:  "Dell",
			CustomerEmail: "[email protected]",
			Traits:        traits,
			Enabled:       true,
		}
	}

	customer, err = customerClient.AddorUpdateCustomer(customer, createCustomerInStripe)
	if err != nil {
		fmt.Println("Error creating customer details: ", err)
	}
  
  customerStatus := fmt.Sprintf("Stripe id for customer: %s", customer.Traits[metering.StripeTraitKey])
	fmt.Println(customerStatus)
}
func setupCustomer() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
	customerId := "dell-8"
	//Automatically create customer in Stripe
	//and add stripeId to traits
	createCustomerInStripe := true

	//Instantiate a new metering client
	customerClient := metering.NewCustomerClient(apiKey)

	//check if customer exists
	customer, err := customerClient.GetCustomer(customerId)
	if err != nil {
		fmt.Println("Error getting customer details: ", err)
	}

	//setup customer
	//Traits are optional. Traits can be used as filters or aggregation buckets.
	if customer != nil {
		//customer exists
		//update properties
		customer.CustomerName = "Dell 2"
	} else {
		//setup new customer
		//Traits are optional. Traits can be used as filters or aggregation buckets.
		traits := make(map[string]string)
		traits["region"] = "us-west"
		traits["customerType"] = "Tech"
		customer = &metering.Customer{
			CustomerId:    customerId,
			CustomerName:  "Dell",
			CustomerEmail: "test@dell.com",
			Traits:        traits,
			Enabled:       true,
		}
	}

	customer, err = customerClient.AddorUpdateCustomer(customer, createCustomerInStripe)
	if err != nil {
		fmt.Println("Error creating customer details: ", err)
	}
  
  customerStatus := fmt.Sprintf("Stripe id for customer: %s", customer.Traits[metering.StripeTraitKey])
	fmt.Println(customerStatus)
}
﻿
7. define custom logger
Go
type CustomLogger struct {
	logger *zerolog.Logger
}

func NewCustomLogger() *CustomLogger {
	logLevel := zerolog.DebugLevel
	zerolog.SetGlobalLevel(logLevel)
	logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
	return &CustomLogger{logger: &logger}
}

func (l *CustomLogger) Log(args ...interface{}) {
	msg := fmt.Sprintln(args...)
	l.logger.Debug().Msg(msg)
}

func (l *CustomLogger) Logf(format string, args ...interface{}) {
	l.logger.Debug().Msgf(format, args...)
}
type CustomLogger struct {
	logger *zerolog.Logger
}

func NewCustomLogger() *CustomLogger {
	logLevel := zerolog.DebugLevel
	zerolog.SetGlobalLevel(logLevel)
	logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
	return &CustomLogger{logger: &logger}
}

func (l *CustomLogger) Log(args ...interface{}) {
	msg := fmt.Sprintln(args...)
	l.logger.Debug().Msg(msg)
}

func (l *CustomLogger) Logf(format string, args ...interface{}) {
	l.logger.Debug().Msgf(format, args...)
}
﻿
8. inject custom logger
Go
func createClientWithCustomerLogger() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
	customerLogger := NewCustomLogger()

	//Instantiate a new metering client with custom logger
	Metering := metering.NewMeteringClient(
		apiKey,
		metering.WithLogger(customerLogger),
	)
}
func createClientWithCustomerLogger() {
	//obtain your Amberflo API Key
	apiKey := "my-api-key"
	customerLogger := NewCustomLogger()

	//Instantiate a new metering client with custom logger
	Metering := metering.NewMeteringClient(
		apiKey,
		metering.WithLogger(customerLogger),
	)
}
﻿
9. Query usage cost
Go
func queryUsageCost(){
  //obtain your Amberflo API Key
	apiKey := "my-api-key"

	customerId := "dell-8"

	//initialize the usage cost client
	usageCostClient := metering.NewUsageCostClient(apiKey)
  
  //set the start time of the time range in Epoch seconds
  startTimeInSeconds := (time.Now().UnixNano() / int64(time.Second)) - (24 * 60 * 60)
	timeRange := &metering.TimeRange{
		StartTimeInSeconds: startTimeInSeconds,
	}

  //specify the limit and sort order
	takeForCost := &metering.Take{
		Limit:       10,
		IsAscending: false,
	}

	// Example 1: group by customers
	// setup usage cost query params
	// visit following link for description of payload:
	// https://docs.amberflo.io/reference/post_payments-cost-usage-cost
	usageCostResult, err := usageCostClient.GetUsageCost(&metering.UsageCostsKey{
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"product_plan_id"},
		TimeRange:            timeRange,
		Take:                 takeForCost,
	})
	fmt.Println("Usage Cost Result")
	printUsageCostData(*usageCostResult, err)

	//Example 2: filter for a cost for specific customer
	//setup usage query params
	filterForCost := make(map[string][]string)
	filterForCost["customerId"] = []string{customerId}

	usageCostResult, err = usageCostClient.GetUsageCost(&metering.UsageCostsKey{
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"product_plan_id"},
		TimeRange:            timeRange,
		Take:                 takeForCost,
		Filters:              filterForCost,
	})
	fmt.Println("Usage cost for specific customer")
	printUsageCostData(*usageCostResult, err)
}

func printUsageCostData(usageCostResult metering.UsageCosts, err error) {
	if err != nil {
		fmt.Println("Usage cost error: ", err)
		return
	}

	jsonString, err := json.MarshalIndent(usageCostResult, "", "  ")
	if err != nil {
		fmt.Println("Usage cost error: ", err)
		return
	}

	fmt.Println(string(jsonString))
}
func queryUsageCost(){
  //obtain your Amberflo API Key
	apiKey := "my-api-key"

	customerId := "dell-8"

	//initialize the usage cost client
	usageCostClient := metering.NewUsageCostClient(apiKey)
  
  //set the start time of the time range in Epoch seconds
  startTimeInSeconds := (time.Now().UnixNano() / int64(time.Second)) - (24 * 60 * 60)
	timeRange := &metering.TimeRange{
		StartTimeInSeconds: startTimeInSeconds,
	}

  //specify the limit and sort order
	takeForCost := &metering.Take{
		Limit:       10,
		IsAscending: false,
	}

	// Example 1: group by customers
	// setup usage cost query params
	// visit following link for description of payload:
	// https://docs.amberflo.io/reference/post_payments-cost-usage-cost
	usageCostResult, err := usageCostClient.GetUsageCost(&metering.UsageCostsKey{
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"product_plan_id"},
		TimeRange:            timeRange,
		Take:                 takeForCost,
	})
	fmt.Println("Usage Cost Result")
	printUsageCostData(*usageCostResult, err)

	//Example 2: filter for a cost for specific customer
	//setup usage query params
	filterForCost := make(map[string][]string)
	filterForCost["customerId"] = []string{customerId}

	usageCostResult, err = usageCostClient.GetUsageCost(&metering.UsageCostsKey{
		TimeGroupingInterval: metering.Day,
		GroupBy:              []string{"product_plan_id"},
		TimeRange:            timeRange,
		Take:                 takeForCost,
		Filters:              filterForCost,
	})
	fmt.Println("Usage cost for specific customer")
	printUsageCostData(*usageCostResult, err)
}

func printUsageCostData(usageCostResult metering.UsageCosts, err error) {
	if err != nil {
		fmt.Println("Usage cost error: ", err)
		return
	}

	jsonString, err := json.MarshalIndent(usageCostResult, "", "  ")
	if err != nil {
		fmt.Println("Usage cost error: ", err)
		return
	}

	fmt.Println(string(jsonString))
}
﻿
﻿
Updated 11 Sep 2024
Did this page help you?
Typescript SDK
Java SDK- ingest with S3