Getting OOM while using the below code.

[karthi8185]

Hi,

While using the below code i am getting Out of memory issue. Is registercallback function using an singletone object and allocate memory which is not free?

meter := otel.Meter("demo-client-meter")    
 var name1 []metric.Int64ObservableGauge                                 
  var name metric.Int64ObservableGauge    
 for _, rowMetric := range data.Value {                                  
                count = 0                                                       
                wg := &sync.WaitGroup{}                                         
                wg.Add(1)                                                       
                rowName := rowMetric.RowName                                    
                for _, value := range rowMetric.Values {                        

                        fullName = fmt.Sprintf(tableName + "/" + rowName + "/" + metricName)
                        name, _ = meter.Int64ObservableGauge(                   
                                fullName,                                       
                        )                                                       
                        fullName1 = append(fullName1, fullName)                 
                        name1 = append(name1, name)                             
                        setMetricValue(fullName, int64(value.Value))            
                        count += 1                                              
                }                                  

  var out []metric.Observable                                     
                for _, inst := range name1 {                                    
                        if in, ok := inst.(wrappedc); ok {                      
                                out = append(out, in.unwrap())                  
                        } else {                                                
                                out = append(out, inst)                         
                        }                                                       
                }                                                               
                go func() {                                                     
                _, err = meter.RegisterCallback(                                
                        func(ctx context.Context, o metric.Observer) error {    
                                for travel := 0; travel < count; travel++ {     
                                        o.ObserveInt64(name1[travel], int64(getMetricValue(fullName1[travel])))
                                }                                               
                                return nil                                      
                        },                                                      
                        out...,                                                 
                )                                                               
                if err != nil {                                                 
                        handleErr(err, fmt.Sprintf("Unable to Register  the callback: %s", tableName))
                }                                                               
                wg.Done()                                                       
                }()                                                             
                wg.Wait()