modelindexer data generator

main.go

package main                                                                                                                
                                                                                                                            
import (                                                                                                                    
        "context"                                                                                                           
        "log"                                                                                                               
        "time"                                                                                                              
                                                                                                                            
        "github.com/elastic/beats/v7/libbeat/logp"                                                                          
                                                                                                                            
        "github.com/elastic/apm-server/elasticsearch"                                                                       
        "github.com/elastic/apm-server/model"                                                                               
        "github.com/elastic/apm-server/model/modelindexer"                                                                  
)                                                                                                                           
                                                                                                                            
func Main() error {                                                                                                         
        logp.DevelopmentSetup()                                                                                             
                                                                                                                            
        cfg := elasticsearch.DefaultConfig()                                                                                
        cfg.Username = "admin"                                                                                              
        cfg.Password = "changeme"                                                                                           
        client, err := elasticsearch.NewClient(cfg)                                                                         
        if err != nil {                                                                                                     
                return err                                                                                                  
        }                                                                                                                   
        indexer, err := modelindexer.New(client, modelindexer.Config{})                                                     
        if err != nil {                                                                                                     
                return err                                                                                                  
        }                                                                                                                   
                                                                                                                            
        var docCount int64                                                                                                  
        var histogram model.Histogram                                                                                       
        for i := 0; i < 1000; i++ {                                                                                         
                value := float64(i)                                                                                         
                count := int64(i + 1)                                                                                       
                docCount += count                                                                                           
                histogram.Counts = append(histogram.Counts, count)                                                          
                histogram.Values = append(histogram.Values, value)                                                          
        }                                                                                                                   
                                                                                                                            
        batch := model.Batch{{                                                                                              
                Processor:   model.TransactionProcessor,                                                                    
                DataStream:  model.DataStream{Type: "traces", Dataset: model.TracesDataset, Namespace: "default"},          
                Event:       model.Event{Duration: time.Second},                                                            
                Transaction: &model.Transaction{},                                                                          
        }, {                                                                                                                
                Processor:   model.MetricsetProcessor,                                                                      
                DataStream:  model.DataStream{Type: "metrics", Dataset: model.InternalMetricsDataset, Namespace: "default"},
                Transaction: &model.Transaction{DurationHistogram: histogram},                                              
                Metricset:   &model.Metricset{DocCount: docCount},                                                          
        }}                                                                                                                  
        for i := 0; i < 10000; i++ {                                                                                        
                if err := indexer.ProcessBatch(context.Background(), &batch); err != nil {                                  
                        return err                                                                                          
                }                                                                                                           
        }                                                                                                                   
                                                                                                                            
        return indexer.Close(context.Background())                                                                          
}                                                                                                                           
                                                                                                                            
func main() {                                                                                                               
        if err := Main(); err != nil {                                                                                      
                log.Fatal(err)                                                                                              
        }                                                                                                                   
}