vm-metrics/main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/url"
	"os"
	"strings"
	"time"
	_ "time/tzdata"

	"github.com/vmware/govmomi"
	"github.com/vmware/govmomi/object"
	"github.com/vmware/govmomi/performance"
	"github.com/vmware/govmomi/view"
	"github.com/vmware/govmomi/vim25"
	"github.com/vmware/govmomi/vim25/mo"
	"github.com/vmware/govmomi/vim25/types"
)

var (
	c         *govmomi.Client
	ctx       context.Context
	cancel    context.CancelFunc
	location  *time.Location
	sha1ver   string // sha1 revision used to build the program
	buildTime string // when the executable was built
)

/*
	func findPerfCounter(perfManager *vim25.PerformanceManager, counterName string) (*vim25.PerfCounterInfo, error) {
		perfCounters, err := perfManager.QueryPerfCounter(context.Background(), nil)
		if err != nil {
			return nil, err
		}

		for _, counter := range perfCounters {
			if counter.NameInfo.GetElement().Key == counterName {
				return &counter, nil
			}
		}

		return nil, fmt.Errorf("Performance counter '%s' not found", counterName)
	}
*/
func findVMByName(ctx context.Context, client *vim25.Client, vmName string) ([]mo.VirtualMachine, error) {
	m := view.NewManager(client)

	vms, err := m.CreateContainerView(ctx, client.ServiceContent.RootFolder, []string{"VirtualMachine"}, true)
	if err != nil {
		return nil, err
	}
	defer vms.Destroy(ctx)

	var matchingVMs []mo.VirtualMachine

	err = vms.Retrieve(ctx, []string{"VirtualMachine"}, []string{"name"}, &matchingVMs)
	if err != nil {
		return nil, err
	}

	var result []mo.VirtualMachine

	for _, vm := range matchingVMs {
		if vm.Name == vmName {
			result = append(result, vm)
		}
	}

	return result, nil
}

func getMetricIds(counters []types.PerfCounterInfo) []types.PerfMetricId {
	var metricIds []types.PerfMetricId
	for _, counter := range counters {
		var metricId types.PerfMetricId
		metricId.CounterId = counter.Key
		metricIds = append(metricIds, metricId)
	}
	return metricIds
}

func getSpecificVMMetrics(ctx context.Context, c *vim25.Client, vmName string) {
	//perfManager := c.ServiceContent.PerfManager
	perfManager := performance.NewManager(c)
	var perfCounterInfos []types.PerfCounterInfo
	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"}

	// Retrieve counters name list
	counters, err := perfManager.CounterInfoByName(ctx)
	if err != nil {
		//return err
		fmt.Printf("Error getting counter info : '%s'\n", err)
		return
	}

	fmt.Printf("Found '%d' counters\n", len(counters))

	for _, counter := range counters {
		for _, counterName := range counterNames {
			if counter.Name() == counterName {
				fmt.Printf("Found counter matching name '%s' : '%v'\n", counterName, counter.PerDeviceLevel)
				perfCounterInfos = append(perfCounterInfos, *counter)
			} else {
				//fmt.Printf("Ignoring '%s' : '%s'\n", counter.StatsType, counter.Name())
			}
		}
	}

	fmt.Printf("Ended search with %d counter infos\n", len(perfCounterInfos))

	// Find the VM by its name
	vmMatches, err := findVMByName(ctx, c, vmName)
	if err != nil {
		fmt.Println("Error finding VM:", err)
		return
	}

	for _, vm := range vmMatches {
		// Create PerfQuerySpec as per https://github.com/vmware/govmomi/blob/main/performance/example_test.go
		spec := types.PerfQuerySpec{
			MaxSample:  1800,
			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()})
		if err != nil {
			fmt.Printf("Error getting SampleByName : '%s'\n", err)
			return
		}

		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 {
			vm := object.NewVirtualMachine(c, metric.Entity)
			name, err := vm.ObjectName(ctx)
			if err != nil {
				fmt.Printf("Error getting vm name : '%s'\n", err)
				return
			}

			fmt.Printf("Vm %s has %d metric values\n", name, len(metric.Value))

			for _, v := range metric.Value {

				counter := counters[v.Name]
				units := counter.UnitInfo.GetElementDescription().Label

				instance := v.Instance
				if instance == "" {
					instance = "-"
				}

				if len(v.Value) != 0 {
					fmt.Printf("%s\t%s\t%s\t%s : %v\n", name, instance, v.Name, units, v.ValueCSV())
				}
			}
		}

		/*
			// Create a query specification
			query := perfManager.QueryPerf(ctx, &vim25.QueryPerf{
				Entity:     []vim25.ManagedObjectReference{vm.Reference()},
				MaxSample:  1,
				MetricId:   getMetricIds(perfCounterInfos),
				IntervalId: 20,                         // 20-second interval
				StartTime:  time.Now().Add(-time.Hour), // 1 hour ago
				EndTime:    time.Now(),
			})

			// Process the query result
			for _, perf := range query {
				fmt.Println("VM:", vmName)
				for i, value := range perf.Value {
					counterInfo := perfCounterInfos[i]
					fmt.Printf("%s: %v\n", counterInfo.NameInfo.GetElement().Key, value.Value[0])
				}
			}
		*/
	}
}

func main() {
	// Command line flags
	vURL := flag.String("url", "", "The URL of a vCenter server, eg https://server.domain.example/sdk")
	vUser := flag.String("user", "", "The username to use when connecting to vCenter")
	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")
	//begin := flag.Duration("b", time.Hour, "Begin time") // default BeginTime is 1h ago
	flag.Parse()

	// Print logs to file
	f, err := os.OpenFile("log.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		log.Fatalf("error opening file: %v", err)
	}
	defer f.Close()
	log.SetOutput(f)

	log.Printf("Starting execution. Built on %s from sha1 %s\n", buildTime, sha1ver)

	// So we can convert vCenter UTC to our local timezone
	log.Printf("Setting timezone to '%s'\n", *vTZ)
	location, err = time.LoadLocation(*vTZ)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error setting timezone to %s : %s\n", *vTZ, err)
		os.Exit(1)
	}

	u, err := url.Parse(*vURL)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error parsing url %s : %s\n", *vURL, err)
		os.Exit(1)
	} else {
		if !strings.HasSuffix(u.Path, "/sdk") {
			u.Path, _ = url.JoinPath(u.Path, "/sdk")
			log.Printf("Updated vCenter URL to '%v'\n", u)
		}
	}

	log.Printf("Connecting to vCenter %s\n", u)
	u.User = url.UserPassword(*vUser, *vPass)

	ctx, cancel = context.WithCancel(context.Background())
	defer cancel()

	// Login to vcenter
	c, err = govmomi.NewClient(ctx, u, *vInsecure)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Logging in error: %s\n", err)
		os.Exit(1)
	}
	defer c.Logout(ctx)

	getSpecificVMMetrics(ctx, c.Client, *vmName)
}