Go

18min

links github 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 see api reference overview 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 see api reference 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 create a customer 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 see api reference 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 see api reference 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 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 see api reference guide 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 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

Java

TypeScript and JavaScript