Add option to enable wildcard expansion (#4265)

This is needed because wildcard expansion causes counters to be localized.

plugins/inputs/win_perf_counters/win_perf_counters.go

@@ -22,6 +22,10 @@ var sampleConfig = `
   ## agent, it will not be gathered.
   ## Settings:
   # PrintValid = false # Print All matching performance counters
+  # If UseWildcardsExpansion params is set to true, wildcards (partial wildcards in instance names and wildcards in counters names) in configured counter paths will be expanded 
+  # and in case of localized Windows, counter paths will be also localized. It also returns instance indexes in instance names.
+  # If false, wildcards (not partial) in instance names will be still expanded, but instance indexes will not be returned in instance names.
+  #UseWildcardsExpansion = false
   # Period after which counters will be reread from configuration and wildcards in counter paths expanded
   CountersRefreshInterval="1m"
 
@@ -75,6 +79,7 @@ type Win_PerfCounters struct {
 	PreVistaSupport         bool
 	Object                  []perfobject
 	CountersRefreshInterval internal.Duration
+	UseWildcardsExpansion   bool
 
 	lastRefreshed time.Time
 	counters      []*counter
@@ -137,45 +142,59 @@ func (m *Win_PerfCounters) SampleConfig() string {
 	return sampleConfig
 }
 
-func (m *Win_PerfCounters) AddItem(counterPath string, instance string, measurement string, includeTotal bool) error {
+//objectName string, counter string, instance string, measurement string, include_total bool
+func (m *Win_PerfCounters) AddItem(counterPath string, objectName string, instance string, counterName string, measurement string, includeTotal bool) error {
+	var err error
+	var counterHandle PDH_HCOUNTER
 	if !m.query.AddEnglishCounterSupported() {
-		_, err := m.query.AddCounterToQuery(counterPath)
+		counterHandle, err = m.query.AddCounterToQuery(counterPath)
 		if err != nil {
 			return err
 		}
 	} else {
-		counterHandle, err := m.query.AddEnglishCounterToQuery(counterPath)
+		counterHandle, err = m.query.AddEnglishCounterToQuery(counterPath)
 		if err != nil {
 			return err
 		}
+
+	}
+
+	if m.UseWildcardsExpansion {
+		origInstance := instance
 		counterPath, err = m.query.GetCounterPath(counterHandle)
 		if err != nil {
 			return err
 		}
-	}
-
-	counters, err := m.query.ExpandWildCardPath(counterPath)
-	if err != nil {
-		return err
-	}
-
-	for _, counterPath := range counters {
-		var err error
-		counterHandle, err := m.query.AddCounterToQuery(counterPath)
-
-		parsedObjectName, parsedInstance, parsedCounter, err := extractObjectInstanceCounterFromQuery(counterPath)
+		counters, err := m.query.ExpandWildCardPath(counterPath)
 		if err != nil {
 			return err
 		}
 
-		if parsedInstance == "_Total" && instance == "*" && !includeTotal {
-			continue
-		}
+		for _, counterPath := range counters {
+			var err error
+			counterHandle, err := m.query.AddCounterToQuery(counterPath)
 
-		newItem := &counter{counterPath, parsedObjectName, parsedCounter, parsedInstance, measurement,
+			objectName, instance, counterName, err = extractObjectInstanceCounterFromQuery(counterPath)
+			if err != nil {
+				return err
+			}
+
+			if instance == "_Total" && origInstance == "*" && !includeTotal {
+				continue
+			}
+
+			newItem := &counter{counterPath, objectName, counterName, instance, measurement,
+				includeTotal, counterHandle}
+			m.counters = append(m.counters, newItem)
+
+			if m.PrintValid {
+				log.Printf("Valid: %s\n", counterPath)
+			}
+		}
+	} else {
+		newItem := &counter{counterPath, objectName, counterName, instance, measurement,
 			includeTotal, counterHandle}
 		m.counters = append(m.counters, newItem)
-
 		if m.PrintValid {
 			log.Printf("Valid: %s\n", counterPath)
 		}
@@ -199,7 +218,7 @@ func (m *Win_PerfCounters) ParseConfig() error {
 						counterPath = "\\" + objectname + "(" + instance + ")\\" + counter
 					}
 
-					err := m.AddItem(counterPath, instance, PerfObject.Measurement, PerfObject.IncludeTotal)
+					err := m.AddItem(counterPath, objectname, instance, counter, PerfObject.Measurement, PerfObject.IncludeTotal)
 
 					if err != nil {
 						if PerfObject.FailOnMissing || PerfObject.WarnOnMissing {
@@ -225,7 +244,9 @@ func (m *Win_PerfCounters) Gather(acc telegraf.Accumulator) error {
 	var err error
 
 	if m.lastRefreshed.IsZero() || (m.CountersRefreshInterval.Duration.Nanoseconds() > 0 && m.lastRefreshed.Add(m.CountersRefreshInterval.Duration).Before(time.Now())) {
-		m.counters = m.counters[:0]
+		if m.counters != nil {
+			m.counters = m.counters[:0]
+		}
 
 		err = m.query.Open()
 		if err != nil {
@@ -261,22 +282,61 @@ func (m *Win_PerfCounters) Gather(acc telegraf.Accumulator) error {
 	// For iterate over the known metrics and get the samples.
 	for _, metric := range m.counters {
 		// collect
-		value, err := m.query.GetFormattedCounterValueDouble(metric.counterHandle)
-		if err == nil {
-			measurement := sanitizedChars.Replace(metric.measurement)
-			if measurement == "" {
-				measurement = "win_perf_counters"
-			}
+		if m.UseWildcardsExpansion {
+			value, err := m.query.GetFormattedCounterValueDouble(metric.counterHandle)
+			if err == nil {
+				measurement := sanitizedChars.Replace(metric.measurement)
+				if measurement == "" {
+					measurement = "win_perf_counters"
+				}
 
-			var instance = InstanceGrouping{measurement, metric.instance, metric.objectName}
-			if collectFields[instance] == nil {
-				collectFields[instance] = make(map[string]interface{})
+				var instance = InstanceGrouping{measurement, metric.instance, metric.objectName}
+				if collectFields[instance] == nil {
+					collectFields[instance] = make(map[string]interface{})
+				}
+				collectFields[instance][sanitizedChars.Replace(metric.counter)] = float32(value)
+			} else {
+				//ignore invalid data from as some counters from process instances returns this sometimes
+				if phderr, ok := err.(*PdhError); ok && phderr.ErrorCode != PDH_INVALID_DATA && phderr.ErrorCode != PDH_CALC_NEGATIVE_VALUE {
+					return fmt.Errorf("error while getting value for counter %s: %v", metric.counterPath, err)
+				}
 			}
-			collectFields[instance][sanitizedChars.Replace(metric.counter)] = float32(value)
 		} else {
-			//ignore invalid data from as some counters from process instances returns this sometimes
-			if phderr, ok := err.(*PdhError); ok && phderr.ErrorCode != PDH_INVALID_DATA && phderr.ErrorCode != PDH_CALC_NEGATIVE_VALUE {
-				return fmt.Errorf("error while getting value for counter %s: %v", metric.counterPath, err)
+			counterValues, err := m.query.GetFormattedCounterArrayDouble(metric.counterHandle)
+			if err == nil {
+				for _, cValue := range counterValues {
+					var add bool
+					if metric.includeTotal {
+						// If IncludeTotal is set, include all.
+						add = true
+					} else if metric.instance == "*" && !strings.Contains(cValue.InstanceName, "_Total") {
+						// Catch if set to * and that it is not a '*_Total*' instance.
+						add = true
+					} else if metric.instance == cValue.InstanceName {
+						// Catch if we set it to total or some form of it
+						add = true
+					} else if strings.Contains(metric.instance, "#") && strings.HasPrefix(metric.instance, cValue.InstanceName) {
+						// If you are using a multiple instance identifier such as "w3wp#1"
+						// phd.dll returns only the first 2 characters of the identifier.
+						add = true
+						cValue.InstanceName = metric.instance
+					} else if metric.instance == "------" {
+						add = true
+					}
+
+					if add {
+						measurement := sanitizedChars.Replace(metric.measurement)
+						if measurement == "" {
+							measurement = "win_perf_counters"
+						}
+						var instance = InstanceGrouping{measurement, cValue.InstanceName, metric.objectName}
+
+						if collectFields[instance] == nil {
+							collectFields[instance] = make(map[string]interface{})
+						}
+						collectFields[instance][sanitizedChars.Replace(metric.counter)] = float32(cValue.Value)
+					}
+				}
 			}
 		}
 	}