Go

18min
Links
﻿Github
Releases﻿
/
1. use amberflo api-key
View
﻿
/
2. setup the metering client
View
﻿
/
3. ingest meters
View
﻿
/
4. shutdown metering client
View
﻿
/
5. query usage
View
﻿
/
6. create customer
View
﻿
/
7. define custom logger
View
﻿
/
8. inject custom logger
View
﻿
/
9. Query usage cost
View
﻿
Quick Start
Text
go get github.com/amberflo/metering-go/[email protected]
go get github.com/amberflo/metering-go/v2@v2.0.1
﻿
Ingesting meters
﻿See API Reference﻿ 
Guide﻿﻿
/
Go
View
﻿
﻿
📘 Cancel an ingested meter﻿
A meter can be cancelled by resending the same ingestion event and setting metering.CancelMeter dimension to "true". See code below.
Cancel ingested meter
dimensions[metering.CancelMeter] = "true"	

//cancel an ingested meter
meteringError := Metering.Meter(&metering.MeterMessage{
  UniqueId:          uniqueId,
  MeterApiName:      "ApiCalls-From-Go",
  CustomerId:        customerId,
  MeterValue:        meterValue,
  MeterTimeInMillis: utcMillis,
  Dimensions:        dimensions,
})
dimensions[metering.CancelMeter] = "true"	

//cancel an ingested meter
meteringError := Metering.Meter(&metering.MeterMessage{
  UniqueId:          uniqueId,
  MeterApiName:      "ApiCalls-From-Go",
  CustomerId:        customerId,
  MeterValue:        meterValue,
  MeterTimeInMillis: utcMillis,
  Dimensions:        dimensions,
})
﻿
Query usage
﻿See API Reference﻿  
Go
package main

import (
	"encoding/json"
	"fmt"

	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {
	customerId := "dell-8"

	//initialize the usage client
	usageClient := metering.NewUsageClient(
		apiKey,
		// metering.WithCustomLogger(customerLogger),
	)

	//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"] = []string{customerId}

	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))
}
package main

import (
	"encoding/json"
	"fmt"

	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {
	customerId := "dell-8"

	//initialize the usage client
	usageClient := metering.NewUsageClient(
		apiKey,
		// metering.WithCustomLogger(customerLogger),
	)

	//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"] = []string{customerId}

	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))
}
﻿

Manage customers
﻿See API Reference﻿ 
/
Manage customers
View
﻿
Custom logger
By default, metering-go uses the default GO logger. You can inject your own logger by implementing the following interface Logger:
Go
type Logger interface {
	Log(v ...interface{})
	Logf(format string, v ...interface{})
}
type Logger interface {
	Log(v ...interface{})
	Logf(format string, v ...interface{})
}
﻿
Define the custom logger:
Go
package main

import (
	"fmt"
	"os"

	"github.com/rs/zerolog"
)

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...)
}
package main

import (
	"fmt"
	"os"

	"github.com/rs/zerolog"
)

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...)
}
﻿
Instantiate metering client with custom logger:
Go
package main

import (
	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {
	customerLogger := NewCustomLogger()

	//Instantiate a new metering client with custom logger
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithLogger(customerLogger),
	)

	//initialize the usage client with custom logger
	usageClient := metering.NewUsageClient(
		apiKey,
		metering.WithCustomLogger(customerLogger),
	)

	//initialize the usage cost client with custom logger
	usageCostClient := metering.NewUsageCostClient(
		apiKey,
		metering.WithCustomLogger(customerLogger),
	)
}
package main

import (
	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {
	customerLogger := NewCustomLogger()

	//Instantiate a new metering client with custom logger
	meteringClient := metering.NewMeteringClient(
		apiKey,
		metering.WithLogger(customerLogger),
	)

	//initialize the usage client with custom logger
	usageClient := metering.NewUsageClient(
		apiKey,
		metering.WithCustomLogger(customerLogger),
	)

	//initialize the usage cost client with custom logger
	usageCostClient := metering.NewUsageCostClient(
		apiKey,
		metering.WithCustomLogger(customerLogger),
	)
}
﻿
Query usage cost with paging
﻿See API Reference﻿ 
/
Query usage cost with paging
View
﻿
Pricing plans
﻿See API Reference﻿ 
Go
package main

import (
	"encoding/json"
	"fmt"

	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {	
	customerId := "dell-8"

	//Assign pricing plan to customer
	productPlanId := "8e880691-1ae8-493b-b0a7-12a71e5dfcca"
	customerPricingClient := metering.NewCustomerPricingPlanClient(apiKey)
	customerPricingPlan, err := customerPricingClient.AddOrUpdate(&metering.CustomerProductPlan{
		ProductPlanId:      productPlanId,
		CustomerId:         customerId,
		StartTimeInSeconds: (time.Now().UnixNano() / int64(time.Second)),
	})

	if err != nil {
		fmt.Println("Error assigning customer plan: ", err)
	}
	pricingStatus := fmt.Sprintf("Customer pricing plan %s assigned to customer %s", customerPricingPlan.ProductPlanId, customerId)
	fmt.Println(pricingStatus)
}
package main

import (
	"encoding/json"
	"fmt"

	"github.com/amberflo/metering-go/v2"
)

//obtain your Amberflo API Key
var apiKey = "my-api-key"

func main() {	
	customerId := "dell-8"

	//Assign pricing plan to customer
	productPlanId := "8e880691-1ae8-493b-b0a7-12a71e5dfcca"
	customerPricingClient := metering.NewCustomerPricingPlanClient(apiKey)
	customerPricingPlan, err := customerPricingClient.AddOrUpdate(&metering.CustomerProductPlan{
		ProductPlanId:      productPlanId,
		CustomerId:         customerId,
		StartTimeInSeconds: (time.Now().UnixNano() / int64(time.Second)),
	})

	if err != nil {
		fmt.Println("Error assigning customer plan: ", err)
	}
	pricingStatus := fmt.Sprintf("Customer pricing plan %s assigned to customer %s", customerPricingPlan.ProductPlanId, customerId)
	fmt.Println(pricingStatus)
}
﻿
Prepaid Client
﻿See API Reference﻿ 
/
Prepaid client
View
﻿
Signals
﻿See API Reference  ﻿ 
Guide﻿
/
Signalis
View
﻿
Batching Records
Amberflo.io libraries are built to support high throughput environments. That means you can safely send hundreds of meter records per second. For example, you can chose to deploy it on a web server that is serving hundreds of requests per second.
However, every call does not result in a HTTP request, but is queued in memory instead. Messages are batched and flushed in the background, allowing for much faster operation. The size of batch and rate of flush can be customized.
Defaults: The library will flush every 100 messages (configuration parameter: BatchSize ) or
if 1 second has passed since the last flush (configuration parameter: IntervalSeconds)
There is a maximum of 500KB per batch request and 32KB per call.
Flush on demand (Blocking call)
You can flush on demand. For example, at the end of your program, you’ll want to flush to make sure there’s nothing left in the queue. Just call the flush method:
metering.Flush()
Please note: Calling this method will block the calling thread until there are no messages left in the queue. So, you’ll want to use it as part of your cleanup scripts and avoid using it as part of the request lifecycle.
Updated 06 Sep 2024
Did this page help you?
Java
TypeScript and JavaScript
Go

Links

Ingesting meters

﻿

Query usage

Manage customers

Custom logger

Query usage cost with paging

Pricing plans

Prepaid Client

Signals

Batching Records

Flush on demand (Blocking call)
