@@ -52,10 +52,10 @@ func main() {
5252 // There are 2 example Gauge instruments (one a Gaussian, one
5353 // a Sine wave), and one Histogram.
5454
55- c1 , _ := meter .SyncInt64 (). Counter (prefix + "counter" )
56- c2 , _ := meter .SyncInt64 (). UpDownCounter (prefix + "updowncounter" )
57- hist , _ := meter .SyncFloat64 (). Histogram (prefix + "histogram" )
58- mmsc , _ := meter .SyncFloat64 (). Histogram ( prefix + "mmsc" ,
55+ c1 , _ := meter .Int64Counter (prefix + "counter" )
56+ c2 , _ := meter .Int64UpDownCounter (prefix + "updowncounter" )
57+ hist , _ := meter .Float64Histogram (prefix + "histogram" )
58+ mmsc , _ := meter .Float64Histogram ( prefix + "mmsc" ,
5959 instrument .WithDescription (`{
6060 "aggregation": "minmaxsumcount"
6161}` ),
@@ -70,7 +70,7 @@ func main() {
7070 mult *= mult
7171
7272 for i := 0 ; i < 10000 ; i ++ {
73- value := math .Abs (mult * (100 + rand .NormFloat64 ()* 100 ))
73+ value := math .Abs (mult * (100 + rand .NormFloat64 ()* 100 ))
7474 hist .Record (ctx , value )
7575 mmsc .Record (ctx , value )
7676 }
@@ -81,61 +81,61 @@ func main() {
8181
8282 startTime := time .Now ()
8383
84- counterObserver , _ := meter .AsyncInt64 (). Counter (
85- prefix + "counterobserver" ,
86- )
87-
88- err := meter . RegisterCallback ([]instrument. Asynchronous { counterObserver },
89- func ( ctx context. Context ) {
90- counterObserver . Observe ( ctx , int64 ( time . Since ( startTime ). Seconds ()))
91- } ,
84+ _ , err := meter .Int64ObservableCounter (
85+ prefix + "counterobserver" ,
86+ instrument . WithInt64Callback (
87+ func ( ctx context. Context , obs instrument. Int64Observer ) error {
88+ obs . Observe ( int64 ( time . Since ( startTime ). Seconds ()))
89+ return nil
90+ },
91+ ) ,
9292 )
9393
9494 if err != nil {
9595 fmt .Printf ("%v" , err )
9696 }
9797
98- updownCounterObserver , _ : = meter .AsyncInt64 (). UpDownCounter (
99- prefix + "updowncounterobserver" ,
100- )
101-
102- err = meter . RegisterCallback ([]instrument. Asynchronous { updownCounterObserver },
103- func ( ctx context. Context ) {
104- updownCounterObserver . Observe ( ctx , - int64 ( time . Since ( startTime ). Seconds ()))
105- } ,
98+ _ , err = meter .Int64ObservableUpDownCounter (
99+ prefix + "updowncounterobserver" ,
100+ instrument . WithInt64Callback (
101+ func ( ctx context. Context , obs instrument. Int64Observer ) error {
102+ obs . Observe ( - int64 ( time . Since ( startTime ). Seconds ()))
103+ return nil
104+ },
105+ ) ,
106106 )
107107
108108 if err != nil {
109109 fmt .Printf ("%v" , err )
110110 }
111111
112- gauge , _ : = meter .AsyncInt64 (). Gauge (
113- prefix + "gauge" ,
114- )
115-
116- err = meter . RegisterCallback ([]instrument. Asynchronous { gauge },
117- func ( ctx context. Context ) {
118- gauge . Observe ( ctx , int64 ( 50 + rand . NormFloat64 () * 50 ))
119- } ,
112+ _ , err = meter .Int64ObservableGauge (
113+ prefix + "gauge" ,
114+ instrument . WithInt64Callback (
115+ func ( ctx context. Context , obs instrument. Int64Observer ) error {
116+ obs . Observe ( int64 ( 50 + rand . NormFloat64 () * 50 ))
117+ return nil
118+ },
119+ ) ,
120120 )
121121
122122 if err != nil {
123123 fmt .Printf ("%v" , err )
124124 }
125125
126- sineWave , _ : = meter .AsyncFloat64 (). Gauge (
127- prefix + "sine_wave" ,
128- )
129-
130- err = meter . RegisterCallback ([]instrument. Asynchronous { sineWave },
131- func ( ctx context. Context ) {
132- secs := float64 ( time . Now (). UnixNano ()) / float64 ( time . Second )
133-
134- sineWave .Observe (ctx , math .Sin (secs / (50 * math .Pi )), attribute .String ("period" , "fastest " ))
135- sineWave .Observe (ctx , math .Sin (secs / (200 * math .Pi )), attribute .String ("period" , "fast " ))
136- sineWave . Observe ( ctx , math . Sin ( secs / ( 1000 * math . Pi )), attribute . String ( "period" , "regular" ))
137- sineWave . Observe ( ctx , math . Sin ( secs / ( 5000 * math . Pi )), attribute . String ( "period" , "slow" ))
138- } ,
126+ _ , err = meter .Float64ObservableGauge (
127+ prefix + "sine_wave" ,
128+ instrument . WithFloat64Callback (
129+ func ( ctx context. Context , obs instrument. Float64Observer ) error {
130+ secs := float64 ( time . Now (). UnixNano ()) / float64 ( time . Second )
131+
132+ obs . Observe ( math . Sin ( secs / ( 50 * math . Pi )), attribute . String ( "period" , "fastest" ) )
133+ obs . Observe ( math . Sin ( secs / ( 200 * math . Pi )), attribute . String ( "period" , "fast" ))
134+ obs .Observe (math .Sin (secs / (1000 * math .Pi )), attribute .String ("period" , "regular " ))
135+ obs .Observe (math .Sin (secs / (5000 * math .Pi )), attribute .String ("period" , "slow " ))
136+ return nil
137+ },
138+ ) ,
139139 )
140140
141141 if err != nil {
0 commit comments