code works now

main.go

@@ -16,7 +16,6 @@ import (
 	"github.com/vmware/govmomi"
 	"github.com/vmware/govmomi/object"
 	"github.com/vmware/govmomi/performance"
-	"github.com/vmware/govmomi/property"
 	"github.com/vmware/govmomi/view"
 	"github.com/vmware/govmomi/vim25"
 	"github.com/vmware/govmomi/vim25/mo"
@@ -44,6 +43,14 @@ type DrsResults struct {
 	NumVmsDrsBucket81To100 int32
 }
 
+// From https://github.com/vmware/govmomi/blob/main/performance/manager.go#L197
+/*
+type groupPerfCounterInfo struct {
+	info map[int32]*types.PerfCounterInfo
+	ids  []types.PerfMetricId
+}
+*/
+
 /*
 	func findPerfCounter(perfManager *vim25.PerformanceManager, counterName string) (*vim25.PerfCounterInfo, error) {
 		perfCounters, err := perfManager.QueryPerfCounter(context.Background(), nil)
@@ -76,15 +83,21 @@ func findVMByName(ctx context.Context, client *vim25.Client, vmName string) ([]m
 		return nil, err
 	}
 
-	var result []mo.VirtualMachine
+	// Temporarily just return all VMs
+	return matchingVMs, nil
 
-	for _, vm := range matchingVMs {
+	/*
-		if vm.Name == vmName {
+		var result []mo.VirtualMachine
-			result = append(result, vm)
+
+		for _, vm := range matchingVMs {
+			if vm.Name == vmName {
+				result = append(result, vm)
+			}
 		}
-	}
 
-	return result, nil
+		return result, nil
+	*/
+
 }
 
 func findClusterByName(ctx context.Context, client *vim25.Client, name string) mo.ClusterComputeResource {
@@ -126,12 +139,15 @@ func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
 	//perfManager := c.ServiceContent.PerfManager
 	perfManager := performance.NewManager(c)
 	var perfCounterInfos []types.PerfCounterInfo
+	var perfCounterNames []string
 	startTime := time.Now().Add(-time.Hour)
 	timeNow := time.Now()
 
 	// Find the performance counters for CPU Entitlement, CPU Consumed, and CPU Demand
-	counterNames := []string{"cpu.entitlement.latest", "cpu.usage.average", "cpu.demand.average", "cpu.readiness.average"}
+	// % Entitled Resource Delivered = Consumed/(min(Demand,Entitlement)) * 100
-	//counterNames := []string{"cpu.entitlement.latest", "cpu.usage.average"}
+	// As per https://www.unknownfault.com/posts/how-is-percentage-entitled-resource/
+	counterNames := []string{"cpu.entitlement.latest", "cpu.usagemhz.none", "cpu.demand.average"}
+	//counterNames := []string{"cpu.entitlement.latest"}
 
 	// Retrieve counters name list
 	counters, err := perfManager.CounterInfoByName(ctx)
@@ -144,6 +160,9 @@ func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
 	fmt.Printf("Found '%d' counters\n", len(counters))
 
 	for _, counter := range counters {
+
+		perfCounterNames = append(perfCounterNames, counter.Name())
+
 		for _, counterName := range counterNames {
 			if counter.Name() == counterName {
 				groupInfo := counter.GroupInfo.GetElementDescription()
@@ -153,7 +172,7 @@ func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
 
 				perfCounterInfos = append(perfCounterInfos, *counter)
 			} else {
-				//fmt.Printf("Ignoring '%s' : '%s'\n", counter.StatsType, counter.Name())
+				log.Printf("Ignoring '%s' : '%s'\n", counter.StatsType, counter.Name())
 			}
 		}
 	}
@@ -167,37 +186,113 @@ func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
 		return
 	}
 
-	for _, vm := range vmMatches {
+	//fmt.Printf("Processing %d vm matches : %v\n", len(vmMatches), vmMatches)
-		// Create PerfQuerySpec as per https://github.com/vmware/govmomi/blob/main/performance/example_test.go
-		spec := types.PerfQuerySpec{
-			//MaxSample:  180, // In one hour there are 180 instances of 20 second intervals
-			MetricId:   getMetricIds(perfCounterInfos),
-			IntervalId: 20,
-			StartTime:  &startTime, // 1 hour ago
-			EndTime:    &timeNow,
-		}
 
-		// Query metrics
+	var vmReferences []types.ManagedObjectReference
-		sample, err := perfManager.SampleByName(ctx, spec, counterNames, []types.ManagedObjectReference{vm.Reference()})
+
+	for _, vm := range vmMatches {
+		vmReferences = append(vmReferences, vm.Reference())
+	}
+
+	//fmt.Printf("Processing %d vm references : %v\n", len(vmReferences), vmReferences)
+
+	// Create PerfQuerySpec as per https://github.com/vmware/govmomi/blob/main/performance/example_test.go
+	spec := types.PerfQuerySpec{
+		//MaxSample:  180, // In one hour there are 180 instances of 20 second intervals
+		MetricId:   getMetricIds(perfCounterInfos),
+		IntervalId: 20,
+		StartTime:  &startTime, // 1 hour ago
+		EndTime:    &timeNow,
+	}
+
+	// Query metrics
+	//sample, err := perfManager.SampleByName(ctx, spec, counterNames, []types.ManagedObjectReference{vm.Reference()})
+	/*
+		sample, err := perfManager.SampleByName(ctx, spec, counterNames, vmReferences)
 		if err != nil {
 			fmt.Printf("Error getting SampleByName : '%s'\n", err)
 			return
 		}
 		fmt.Printf("Sample result is %d\n", len(sample))
+	*/
 
-		/*
+	var query []types.PerfQuerySpec
-			for _, v := range sample {
+
-				fmt.Printf("%v\n", v.GetPerfEntityMetricBase().Entity)
+	for _, e := range vmMatches {
+		spec.Entity = e.Reference()
+		query = append(query, spec)
+	}
+
+	sample, err := perfManager.Query(ctx, query)
+	if err != nil {
+		fmt.Printf("Error running query : '%s'\n", err)
+		return
+	}
+
+	/*
+		for _, v := range sample {
+			fmt.Printf("%v\n", v.GetPerfEntityMetricBase().Entity)
+		}
+	*/
+
+	allCounters, err := perfManager.CounterInfoByKey(ctx)
+	if err != nil {
+		fmt.Printf("Error getting CounterInfoByKey : '%s'\n", err)
+		return
+	}
+
+	var result []performance.EntityMetric
+
+	for i := range sample {
+		fmt.Printf("Processing sample %d\n", i)
+		var values []performance.MetricSeries
+		s, ok := sample[i].(*types.PerfEntityMetric)
+		if !ok {
+			panic(fmt.Errorf("expected type %T, got: %T", s, sample[i]))
+		}
+		fmt.Printf("Found %d samples\n", len(s.Value))
+		//fmt.Printf("%v\n", sample[i])
+
+		for j := range s.Value {
+			v := s.Value[j].(*types.PerfMetricIntSeries)
+			info, ok := allCounters[v.Id.CounterId]
+			if !ok {
+				continue
 			}
-		*/
 
-		result, err := perfManager.ToMetricSeries(ctx, sample)
+			vm := object.NewVirtualMachine(c, s.Entity)
-		if err != nil {
+			entityName, err := vm.ObjectName(ctx)
-			fmt.Printf("Error getting ToMetricSeries : '%s'\n", err)
+			if err != nil {
-			return
+				fmt.Printf("Error getting vm name : '%s'\n", err)
+				return
+			}
+			fmt.Printf("%s\t%s\t%s\t%v (%s)\n", entityName, info.Name(), v.Id.Instance, v.Value, info.UnitInfo.GetElementDescription().Key)
+
+			/*
+				values = append(values, performance.MetricSeries{
+					Name:     info.Name(),
+					unit:     info.UnitInfo.GetElementDescription().Key,
+					Instance: v.Id.Instance,
+					Value:    v.Value,
+				})
+			*/
 		}
 
-		fmt.Printf("Retrieved %d metric series\n", len(result))
+		result = append(result, performance.EntityMetric{
+			Entity:     s.Entity,
+			SampleInfo: s.SampleInfo,
+			Value:      values,
+		})
+	}
+	/*
+			result, err := perfManager.ToMetricSeries(ctx, sample)
+			if err != nil {
+				fmt.Printf("Error getting ToMetricSeries : '%s'\n", err)
+				return
+			}
+
+			fmt.Printf("Retrieved %d metric series\n", len(result))
+
 
 		// Read result
 		for _, metric := range result {
@@ -223,34 +318,34 @@ func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
 
 				if len(v.Value) != 0 {
 					//fmt.Printf("%s\t%s\t%s\t%s : %v\n", name, instance, v.Name, units, v.ValueCSV())
-					fmt.Printf("%s\t%s\t%s\t%s : %v (%d)\n", name, instance, v.Name, units, v.Value, len(v.Value))
+					fmt.Printf("%s\t%s\t%s\t%s : %v\n", name, instance, v.Name, units, v.Value)
 				}
 			}
 		}
 
 		fmt.Printf("Finished receiving result.\n")
+	*/
 
-		/*
+	/*
-			// Create a query specification
+		// Create a query specification
-			query := perfManager.QueryPerf(ctx, &vim25.QueryPerf{
+		query := perfManager.QueryPerf(ctx, &vim25.QueryPerf{
-				Entity:     []vim25.ManagedObjectReference{vm.Reference()},
+			Entity:     []vim25.ManagedObjectReference{vm.Reference()},
-				MaxSample:  1,
+			MaxSample:  1,
-				MetricId:   getMetricIds(perfCounterInfos),
+			MetricId:   getMetricIds(perfCounterInfos),
-				IntervalId: 20,                         // 20-second interval
+			IntervalId: 20,                         // 20-second interval
-				StartTime:  time.Now().Add(-time.Hour), // 1 hour ago
+			StartTime:  time.Now().Add(-time.Hour), // 1 hour ago
-				EndTime:    time.Now(),
+			EndTime:    time.Now(),
-			})
+		})
 
-			// Process the query result
+		// Process the query result
-			for _, perf := range query {
+		for _, perf := range query {
-				fmt.Println("VM:", vmName)
+			fmt.Println("VM:", vmName)
-				for i, value := range perf.Value {
+			for i, value := range perf.Value {
-					counterInfo := perfCounterInfos[i]
+				counterInfo := perfCounterInfos[i]
-					fmt.Printf("%s: %v\n", counterInfo.NameInfo.GetElement().Key, value.Value[0])
+				fmt.Printf("%s: %v\n", counterInfo.NameInfo.GetElement().Key, value.Value[0])
-				}
 			}
-		*/
+		}
-	}
+	*/
 }
 
 // From https://stackoverflow.com/a/33769379
@@ -266,83 +361,6 @@ func query(t reflect.Type) {
 	Scan(value)
 }
 
-func getNumVmsPerDrsScoreBucket(client *govmomi.Client) error {
-	//properties := []string{"drsVmConfig.numVmPerDrsScoreBucket"}
-	ctx := context.Background()
-	m := view.NewManager(client.Client)
-
-	clusters, err := m.CreateContainerView(ctx, client.ServiceContent.RootFolder, []string{"ClusterComputeResource"}, true)
-	if err != nil {
-		return err
-	}
-	defer clusters.Destroy(ctx)
-
-	var clusterList []mo.ClusterComputeResource
-
-	err = clusters.Retrieve(ctx, []string{"ClusterComputeResource"}, nil, &clusterList)
-	if err != nil {
-		log.Printf("Error retrieving cluster list : '%s'\n", err)
-		return err
-	}
-
-	for _, cluster := range clusterList {
-		log.Printf("Cluster: %s\n", cluster.Name)
-
-		pc := property.DefaultCollector(client.Client)
-		clusterProps := mo.ClusterComputeResource{}
-
-		//err := pc.RetrieveOne(ctx, cluster.Reference(), properties, &clusterProps)
-		err := pc.RetrieveOne(ctx, cluster.Reference(), nil, &clusterProps)
-		if err != nil {
-			log.Printf("Error retrieving property : '%s'\n", err)
-			return err
-		}
-
-		// Properties defined at https://vdc-download.vmware.com/vmwb-repository/dcr-public/bf660c0a-f060-46e8-a94d-4b5e6ffc77ad/208bc706-e281-49b6-a0ce-b402ec19ef82/SDK/vsphere-ws/docs/ReferenceGuide/vim.ClusterComputeResource.Summary.html
-		ccr := clusterProps.Summary.(*types.ClusterComputeResourceSummary)
-		/*
-			fmt.Printf("DRS Score: %v\n", ccr.DrsScore)
-			fmt.Printf("VMs in DRS Score Bucket 0%% to 20%% : %d\n", ccr.NumVmsPerDrsScoreBucket[0])
-			fmt.Printf("VMs in DRS Score Bucket 21%% to 40%% : %d\n", ccr.NumVmsPerDrsScoreBucket[1])
-			fmt.Printf("VMs in DRS Score Bucket 41%% to 60%% : %d\n", ccr.NumVmsPerDrsScoreBucket[2])
-			fmt.Printf("VMs in DRS Score Bucket 61%% to 80%% : %d\n", ccr.NumVmsPerDrsScoreBucket[3])
-			fmt.Printf("VMs in DRS Score Bucket 81%% to 100%% : %d\n", ccr.NumVmsPerDrsScoreBucket[4])
-		*/
-
-		// Create a new result
-		result := DrsResults{
-			Vcenter:                client.URL().Host,
-			ClusterName:            cluster.Name,
-			DrsScore:               ccr.DrsScore,
-			NumVmsDrsBucket0To20:   ccr.NumVmsPerDrsScoreBucket[0],
-			NumVmsDrsBucket21To40:  ccr.NumVmsPerDrsScoreBucket[1],
-			NumVmsDrsBucket41To60:  ccr.NumVmsPerDrsScoreBucket[2],
-			NumVmsDrsBucket61To80:  ccr.NumVmsPerDrsScoreBucket[3],
-			NumVmsDrsBucket81To100: ccr.NumVmsPerDrsScoreBucket[4],
-		}
-		// Append to list of all results
-		results = append(results, result)
-
-		/*
-			// Print properties (fields)
-			objType := reflect.TypeOf(clusterProps)
-			for i := 0; i < objType.NumField(); i++ {
-				field := objType.Field(i)
-				fmt.Printf("Field %d: %s (Type: %s)\n", i, field.Name, field.Type)
-			}
-
-			// Print methods
-			methods := reflect.TypeOf(clusterProps)
-			for i := 0; i < methods.NumMethod(); i++ {
-				method := methods.Method(i)
-				fmt.Printf("Method %d: %s\n", i, method.Name)
-			}
-		*/
-	}
-
-	return nil
-}
-
 func main() {
 	// Command line flags
 	vURL := flag.String("url", "", "The URL of a vCenter server, eg https://server.domain.example/sdk")
@@ -350,7 +368,7 @@ func main() {
 	vPass := flag.String("password", "", "The password to use when connecting to vCenter")
 	vTZ := flag.String("tz", "Australia/Sydney", "The timezone to use when converting vCenter UTC times")
 	vInsecure := flag.Bool("insecure", true, "Allow insecure connections to vCenter")
-	//vmName := flag.String("vmname", "example-vm", "The vm to query metrics")
+	vmName := flag.String("vmname", "example-vm", "The vm to query metrics")
 	//begin := flag.Duration("b", time.Hour, "Begin time") // default BeginTime is 1h ago
 	flag.Parse()
 
@@ -397,8 +415,8 @@ func main() {
 	}
 	defer c.Logout(ctx)
 
-	//getSpecificVMMetrics(ctx, c.Client, *vmName)
+	getSpecificVMMetrics(ctx, c.Client, *vmName)
-	err = getNumVmsPerDrsScoreBucket(c)
+	//err = getNumVmsPerDrsScoreBucket(c)
 	if err != nil {
 		log.Printf("Error retrieving NumVmsPerDrsScoreBucket: %s\n", err)
 		return