Add an input plugin to monitor basic info of Windows Services

Godeps_windows

@@ -2,7 +2,7 @@ github.com/Microsoft/go-winio ce2922f643c8fd76b46cadc7f404a06282678b34
 github.com/StackExchange/wmi f3e2bae1e0cb5aef83e319133eabfee30013a4a5
 github.com/go-ole/go-ole be49f7c07711fcb603cff39e1de7c67926dc0ba7
 github.com/shirou/w32 3c9377fc6748f222729a8270fe2775d149a249ad
-golang.org/x/sys a646d33e2ee3172a661fc09bca23bb4889a41bc8
+golang.org/x/sys 739734461d1c916b6c72a63d7efda2b27edb369f
 github.com/go-ini/ini 9144852efba7c4daf409943ee90767da62d55438
 github.com/jmespath/go-jmespath bd40a432e4c76585ef6b72d3fd96fb9b6dc7b68d
 github.com/pmezard/go-difflib/difflib 792786c7400a136282c1664665ae0a8db921c6c2

plugins/inputs/all/all.go

@@ -87,6 +87,7 @@ import (
 	_ "github.com/influxdata/telegraf/plugins/inputs/varnish"
 	_ "github.com/influxdata/telegraf/plugins/inputs/webhooks"
 	_ "github.com/influxdata/telegraf/plugins/inputs/win_perf_counters"
+	_ "github.com/influxdata/telegraf/plugins/inputs/win_services"
 	_ "github.com/influxdata/telegraf/plugins/inputs/zfs"
 	_ "github.com/influxdata/telegraf/plugins/inputs/zookeeper"
 )

plugins/inputs/win_services/README.md

@@ -0,0 +1,68 @@
+# Telegraf Plugin: win_services
+Input plugin to report Windows services info.
+
+It requires that Telegraf must be running under the administrator privileges.
+### Configuration:
+
+```toml
+[[inputs.win_services]]
+  ## Names of the services to monitor. Leave empty to monitor all the available services on the host
+  service_names = [
+    "LanmanServer",
+    "TermService",
+  ]
+```
+
+### Measurements & Fields:
+
+- win_services
+    - state : integer
+    - startup_mode : integer
+
+The `state` field can have the following values:
+- 1 - stopped
+- 2 - start pending
+- 3 - stop pending
+- 4 - running
+- 5 - continue pending
+- 6 - pause pending 
+- 7 - paused
+
+The `startup_mode` field can have the following values:
+- 0 - boot start
+- 1 - system start
+- 2 - auto start
+- 3 - demand start
+- 4 - disabled   
+
+### Tags:
+
+- All measurements have the following tags:
+    - service_name
+    - display_name
+
+### Example Output:
+```
+* Plugin: inputs.win_services, Collection 1
+> win_services,host=WIN2008R2H401,display_name=Server,service_name=LanmanServer state=4i,startup_mode=2i 1500040669000000000
+> win_services,display_name=Remote\ Desktop\ Services,service_name=TermService,host=WIN2008R2H401 state=1i,startup_mode=3i 1500040669000000000
+```
+### TICK Scripts
+
+A sample TICK script for a notification about a not running service.
+It sends a notification whenever any service changes its state to be not _running_ and when it changes that state back to _running_. 
+The notification is sent via an HTTP POST call.
+
+```
+stream
+    |from()
+        .database('telegraf')
+        .retentionPolicy('autogen')
+        .measurement('win_services')
+        .groupBy('host','service_name')
+    |alert()
+        .crit(lambda: "state" != 4)
+        .stateChangesOnly()
+        .message('Service {{ index .Tags "service_name" }} on Host {{ index .Tags "host" }} is in state {{ index .Fields "state" }} ')
+        .post('http://localhost:666/alert/service')
+```

plugins/inputs/win_services/win_services.go

@@ -0,0 +1,172 @@
+// +build windows
+
+package win_services
+
+import (
+	"fmt"
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/inputs"
+	"golang.org/x/sys/windows/svc/mgr"
+)
+
+var sampleConfig = `
+  ## Names of the services to monitor. Leave empty to monitor all the available services on the host
+  service_names = [
+    "LanmanServer",
+    "TermService",
+  ]
+`
+
+var description = "Input plugin to report Windows services info."
+
+type Win_Services struct {
+	ServiceNames []string `toml:"service_names"`
+}
+
+type ServiceInfo struct {
+	ServiceName string
+	DisplayName string
+	State       int
+	StartUpMode int
+	Error       error
+}
+
+var ServiceStatesMap = map[int]string{
+	0x00000001: "stopped",
+	0x00000002: "start_pending",
+	0x00000003: "stop_pending",
+	0x00000004: "running",
+	0x00000005: "continue_pending",
+	0x00000006: "pause_pending",
+	0x00000007: "paused",
+}
+
+var ServiceStartupModeMap = map[int]string{
+	0x00000000: "boot_start",
+	0x00000001: "system_start",
+	0x00000002: "auto_start",
+	0x00000003: "demand_start",
+	0x00000004: "disabled",
+}
+
+func (m *Win_Services) Description() string {
+	return description
+}
+
+func (m *Win_Services) SampleConfig() string {
+	return sampleConfig
+}
+
+func (m *Win_Services) Gather(acc telegraf.Accumulator) error {
+
+	serviceInfos, err := listServices(m.ServiceNames)
+
+	if err != nil {
+		return err
+	}
+
+	for _, service := range serviceInfos {
+		if service.Error == nil {
+			fields := make(map[string]interface{})
+			tags := make(map[string]string)
+
+			tags["display_name"] = service.DisplayName
+			tags["service_name"] = service.ServiceName
+
+			fields["state"] = service.State
+			fields["startup_mode"] = service.StartUpMode
+
+			acc.AddFields("win_services", fields, tags)
+		} else {
+			acc.AddError(service.Error)
+		}
+	}
+
+	return nil
+}
+
+func listServices(userServices []string) ([]ServiceInfo, error) {
+	scmgr, err := mgr.Connect()
+	if err != nil {
+		return nil, fmt.Errorf("Could not open service manager: %s", err)
+	}
+	defer scmgr.Disconnect()
+
+	var serviceNames []string
+	if len(userServices) == 0 {
+		//Listing service names from system
+		serviceNames, err = scmgr.ListServices()
+		if err != nil {
+			return nil, fmt.Errorf("Could not list services: %s", err)
+		}
+	} else {
+		serviceNames = userServices
+	}
+	serviceInfos := make([]ServiceInfo, len(serviceNames))
+
+	for i, srvName := range serviceNames {
+		serviceInfos[i] = collectServiceInfo(scmgr, srvName)
+	}
+
+	return serviceInfos, nil
+}
+
+func collectServiceInfo(scmgr *mgr.Mgr, serviceName string) (serviceInfo ServiceInfo) {
+
+	serviceInfo.ServiceName = serviceName
+	srv, err := scmgr.OpenService(serviceName)
+	if err != nil {
+		serviceInfo.Error = fmt.Errorf("Could not open service '%s': %s", serviceName, err)
+		return
+	}
+	defer srv.Close()
+
+	//While getting service info there could a theoretically a lot of errors on different places.
+	//However in reality if there is a problem with a service then usually openService fails and if it passes, other calls will most probably be ok
+	//So, following error checking is just for sake
+	srvStatus, err := srv.Query()
+	if err == nil {
+		state := int(srvStatus.State)
+		if !checkState(state) {
+			serviceInfo.Error = fmt.Errorf("Uknown state of Service %s: %d", serviceName, state)
+			//finish collecting info on first found error
+			return
+		}
+		serviceInfo.State = state
+	} else {
+		serviceInfo.Error = fmt.Errorf("Could not query service '%s': %s", serviceName, err)
+		//finish collecting info on first found error
+		return
+	}
+
+	srvCfg, err := srv.Config()
+	if err == nil {
+		startupMode := int(srvCfg.StartType)
+		if !checkStartupMode(startupMode) {
+			serviceInfo.Error = fmt.Errorf("Uknown startup mode of Service %s: %d", serviceName, startupMode)
+			//finish collecting info on first found error
+			return
+		}
+		serviceInfo.DisplayName = srvCfg.DisplayName
+		serviceInfo.StartUpMode = startupMode
+	} else {
+		serviceInfo.Error = fmt.Errorf("Could not get config of service '%s': %s", serviceName, err)
+	}
+	return
+}
+
+//returns true of state is in valid range
+func checkState(state int) bool {
+	_, ok := ServiceStatesMap[state]
+	return ok
+}
+
+//returns true of startup mode is in valid range
+func checkStartupMode(startupMode int) bool {
+	_, ok := ServiceStartupModeMap[startupMode]
+	return ok
+}
+
+func init() {
+	inputs.Add("win_services", func() telegraf.Input { return &Win_Services{} })
+}

plugins/inputs/win_services/win_services_notwindows.go

@@ -0,0 +1,3 @@
+// +build !windows
+
+package win_services

plugins/inputs/win_services/win_services_test.go

@@ -0,0 +1,101 @@
+// +build windows
+
+//this test must be run under administrator account
+package win_services
+
+import (
+	"github.com/influxdata/telegraf/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sys/windows/svc/mgr"
+	"testing"
+)
+
+var InvalidServices = []string{"XYZ1@", "ZYZ@", "SDF_@#"}
+var KnownServices = []string{"LanmanServer", "TermService"}
+
+func TestList(t *testing.T) {
+	services, err := listServices(KnownServices)
+	require.NoError(t, err)
+	assert.Len(t, services, 2, "Different number of services")
+	assert.Equal(t, services[0].ServiceName, KnownServices[0])
+	assert.Nil(t, services[0].Error)
+	assert.Equal(t, services[1].ServiceName, KnownServices[1])
+	assert.Nil(t, services[1].Error)
+}
+
+func TestEmptyList(t *testing.T) {
+	services, err := listServices([]string{})
+	require.NoError(t, err)
+	assert.Condition(t, func() bool { return len(services) > 20 }, "Too few service")
+}
+
+func TestListEr(t *testing.T) {
+	services, err := listServices(InvalidServices)
+	require.NoError(t, err)
+	assert.Len(t, services, 3, "Different number of services")
+	for i := 0; i < 3; i++ {
+		assert.Equal(t, services[i].ServiceName, InvalidServices[i])
+		assert.NotNil(t, services[i].Error)
+	}
+}
+
+func TestGather(t *testing.T) {
+	ws := &Win_Services{KnownServices}
+	assert.Len(t, ws.ServiceNames, 2, "Different number of services")
+	var acc testutil.Accumulator
+	require.NoError(t, ws.Gather(&acc))
+	assert.Len(t, acc.Errors, 0, "There should be no errors after gather")
+
+	for i := 0; i < 2; i++ {
+		fields := make(map[string]interface{})
+		tags := make(map[string]string)
+		si := getServiceInfo(KnownServices[i])
+		fields["state"] = int(si.State)
+		fields["startup_mode"] = int(si.StartUpMode)
+		tags["service_name"] = si.ServiceName
+		tags["display_name"] = si.DisplayName
+		acc.AssertContainsTaggedFields(t, "win_services", fields, tags)
+	}
+
+}
+
+func TestGatherErrors(t *testing.T) {
+	ws := &Win_Services{InvalidServices}
+	assert.Len(t, ws.ServiceNames, 3, "Different number of services")
+	var acc testutil.Accumulator
+	require.NoError(t, ws.Gather(&acc))
+	assert.Len(t, acc.Errors, 3, "There should be 3 errors after gather")
+}
+
+func getServiceInfo(srvName string) *ServiceInfo {
+
+	scmgr, err := mgr.Connect()
+	if err != nil {
+		return nil
+	}
+	defer scmgr.Disconnect()
+
+	srv, err := scmgr.OpenService(srvName)
+	if err != nil {
+		return nil
+	}
+	var si ServiceInfo
+	si.ServiceName = srvName
+	srvStatus, err := srv.Query()
+	if err == nil {
+		si.State = int(srvStatus.State)
+	} else {
+		si.Error = err
+	}
+
+	srvCfg, err := srv.Config()
+	if err == nil {
+		si.DisplayName = srvCfg.DisplayName
+		si.StartUpMode = int(srvCfg.StartType)
+	} else {
+		si.Error = err
+	}
+	srv.Close()
+	return &si
+}