PLATFORM SDK
Go
18 min
links https //github com/amberflo/metering go https //github com/amberflo/metering go/releases 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} 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() } 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 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) } 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 ) } 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 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)) }{"success"\ true} quick start go get github com/amberflo/metering go/v2\@v2 0 1 ingesting meters docid\ nsjpk3f7duakp 05pfyhv package main import ( 	"fmt" 	"time" 	"github com/amberflo/metering go/v2" 	"github com/xtgo/uuid" ) //obtain your amberflo api key var apikey = "my api key" func main() { 	//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), 	) 	customerid = "dell 10" 	//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 customerid, 	 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() } 📘 cancel an ingested meter 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, }) query usage docid\ ufdmrzuwlnrkjrdr bjj 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 docid\ iwtzya4jwllxbgp3qazsl package main import ( 	"fmt" 	"github com/amberflo/metering go/v2" ) //obtain your amberflo api key var apikey = "my api key" func main() { 	customerid = "dell 8" 	//automatically create customer in stripe //and add stripeid to traits 	createcustomerinstripe = true 	//initialize the customer client 	customerclient = metering newcustomerclient( 	 apikey, 	 //metering withcustomlogger(customerlogger), 	) 	//check if customer exists 	customer, err = customerclient getcustomer(customerid) 	if err != nil { 	 fmt println("error getting customer details ", err) 	} 	//setup customer 	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" 	 //in case createcustomerinstripe is false, set the trait for stripeid 	 //traits\[metering stripetraitkey] = "cus lvxxpbqvyn3v49" 	 //set the aws marketplace id trait 	 //traits\[metering awsmarketplacetraitkey] = "aws marketplace id" 	 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) } custom logger by default, metering go uses the default go logger you can inject your own logger by implementing the following interface logger type logger interface { 	log(v interface{}) 	logf(format string, v interface{}) } define the custom logger 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 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 docid\ arr7x fdequk7pukn3vu 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 cost client 	usagecostclient = metering newusagecostclient( 	 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, 	} 	// paging 	pageindex = int64(1) 	page = \&metering page{ 	 number pageindex, 	 size 2, 	} 	// example 1 group by product plan 	// setup usage cost query params 	// visit following link for description of payload 	// https //docs amberflo io/reference/post payments cost usage cost 	for pageindex < 5 { 	 usagecostresultforpage, err = usagecostclient getusagecost(\&metering usagecostskey{ 	 timegroupinginterval metering day, 	 groupby \[]string{"product plan id"}, 	 timerange timerange, 	 page page, 	 }) 	 fmt println("usage cost result for page ", pageindex) 	 printusagecostdata( usagecostresultforpage, err) 	 //increment the page number 	 pageindex = pageindex + 1 	 //obtain total pages from result and stop if limit reached 	 if usagecostresultforpage pageinfo totalpages < pageindex { 	 break 	 } 	 page number = pageindex 	 //a token from a previous query page result to track pages and improve performance 	 pagetoken = usagecostresultforpage pageinfo pagetoken 	 page token = pagetoken 	} } 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)) } pricing plans docid\ kl74kas4 pdfhtdwo8eir 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 docid 6nfak8mjxnkmwdlfcbarr package main import ( 	"fmt" 	"time" 	"github com/amberflo/metering go/v2" 	"github com/xtgo/uuid" ) //obtain your amberflo api key var apikey = "my api key" func main() { 	customerid = "dell 1800" 	starttimeinseconds = (time now() unixnano() / int64(time second)) (1 24 60 60) 	// 	// 	//prepaid sdk 	//initialize the prepaidclient 	prepaidclient = metering newprepaidclient( 	 apikey, 	 //use a custom logger 	 //metering withcustomlogger(customerlogger), for custom logger 	) 	recurrencefrequency = \&metering billingperiod{ 	 interval metering day, 	 intervalscount 1, 	} 	prepaidorder = \&metering customerprepaid{ 	 id uuid newrandom() string(), 	 customerid customerid, 	 externalpayment true, 	 starttimeinseconds starttimeinseconds, 	 prepaidprice 123, 	 prepaidofferversion 1, 	 recurrencefrequency recurrencefrequency, 	} 	// create a prepaid order 	prepaidorder, err = prepaidclient createprepaidorder(prepaidorder) 	if err != nil { 	 fmt println("prepaid api error ", err) 	 return 	} 	// get a list of all active prepaid orders 	prepaidorders, err = prepaidclient getactiveprepaidorders(customerid) 	if err != nil { 	 fmt println("prepaid api error ", err) 	 return 	} 	// update the external payment status of a prepaid order 	externalprepaidpaymentstatus = \&metering externalprepaidpaymentstatus{ 	 paymentstatus metering settled, 	 systemname "stripe", 	 paymentid "payment id 1", 	 paymenttimeinseconds (time now() unixnano() / int64(time second)), 	 prepaiduri prepaidorder firstinvoiceuri, 	} 	externalprepaidpaymentstatus, err = prepaidclient updateexternalprepaidstatus(externalprepaidpaymentstatus) 	// delete a prepaid order 	err = prepaidclient deleteprepaidorder(prepaidorder id, customerid) 	if err != nil { 	 fmt println("prepaid api error ", err) 	 return 	} } signals https //docs amberflo io/reference docid pviyr9ue6iebpqc1hlz package main import ( 	"encoding/json" 	"fmt" 	"github com/amberflo/metering go/v2" ) //obtain your amberflo api key var apikey = "my api key" func main() { 	signalsclient = metering newsignalsclient( 	 apikey, 	 //use a custom logger 	 //metering withcustomlogger(customlogger), 	) 	invoicealert = \&metering notification{ 	 name "invoice tracker alert", 	 notificationtype metering invoice, 	 email \[]string{"amberflo tester\@gmail com"}, 	 thresholdvalue "200", 	 customerfiltermode metering percustomer, 	 enabled true, 	} 	//create a new signal 	invoicealert, err = signalsclient createsignal(invoicealert) 	if err != nil { 	 fmt println("api error ", err) 	 return 	} 	//update an existing signal 	invoicealert thresholdvalue = "150" 	invoicealert enabled = false //disable a signal without deleting 	invoicealert, err = signalsclient updatesignal(invoicealert) 	if err != nil { 	 fmt println("api error ", err) 	 return 	} 	//get an existing signal 	invoicealert, err = signalsclient getsignal(invoicealert id) 	if err != nil { 	 fmt println("api error ", err) 	 return 	} 	//delete a signal 	invoicealert, err = signalsclient deletesignal(invoicealert id) 	if err != nil { 	 fmt println("api error ", err) 	 return 	} 	fmt println("signal with following id deleted ", invoicealert id) } batching records the amberflo go sdk is built for high throughput environments and can safely handle hundreds of meter records per second for example, it can be deployed on a web server handling hundreds of requests per second without impacting performance each call to the sdk does not immediately trigger an http request instead, meter records are queued in memory, batched in the background, and sent periodically this batching behavior significantly improves efficiency and throughput by default the sdk flushes the queue after 100 messages (batchsize) or after 1 second has passed since the last flush (intervalseconds) each batch is limited to 500 kb , and individual events are limited to 32 kb both the batch size and flush interval are configurable manual flush (blocking call) you can flush the queue manually to ensure all pending records are sent—for example, at the end of a program or script to do this, call metering flush() note this is a blocking call it will pause the current thread until all messages in the queue have been flushed use it during cleanup or shutdown, and avoid using it as part of your request lifecycle
