性能计数器数据收集服务

本文演示了一个Windows服务收集性能计数器的数据，将性能计数器数据写入数据库。Windows服务中调用WebAPI服务中。下面简要介绍下我的改造，项目虽小，其中用到了众多的开源项目Topshelf、NLog、Dapper，ASP.NET Web API,Newtonsoft.Json等等：

1、数据库模型，以下是MS SQL Server的模型：

USE [PerfmonCounter]
GO
/****** Object:  Table [dbo].[service_counter_snapshots]    Script Date: 01/25/2013 22:40:20 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[service_counter_snapshots](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [ServiceCounterId] [int] NOT NULL,
    [SnapshotMachineName] [varchar](100) NULL,
    [CreationTimeUtc] [datetime] NOT NULL,
    [ServiceCounterValue] [float] NULL,
PRIMARY KEY CLUSTERED
(
    [Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Object:  Table [dbo].[services]    Script Date: 01/25/2013 22:40:20 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[services](
    [Name] [varchar](100) NOT NULL,
    [DisplayName] [varchar](1000) NULL,
PRIMARY KEY CLUSTERED
(
    [Name] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Object:  Table [dbo].[service_counters]    Script Date: 01/25/2013 22:40:20 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[service_counters](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [ServiceName] [varchar](100) NOT NULL,
    [MachineName] [varchar](100) NULL,
    [CategoryName] [varchar](100) NOT NULL,
    [CounterName] [varchar](100) NOT NULL,
    [InstanceName] [varchar](100) NULL,
    [DisplayName] [varchar](1000) NULL,
    [DisplayType] [varchar](7) NOT NULL,
PRIMARY KEY CLUSTERED
(
    [Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Object:  Default [DF__service_c__Displ__08EA5793]    Script Date: 01/25/2013 22:40:20 ******/
ALTER TABLE [dbo].[service_counters] ADD  DEFAULT ('table') FOR [DisplayType]
GO
/****** Object:  ForeignKey [FK__service_c__Servi__09DE7BCC]    Script Date: 01/25/2013 22:40:20 ******/
ALTER TABLE [dbo].[service_counters]  WITH CHECK ADD FOREIGN KEY([ServiceName])
REFERENCES [dbo].[services] ([Name])
GO

services表 存储我们需要监控的服务的进程。 每个服务都需要监控一系列的性能计数器 (存储在 service_counters 表)。数据收集服务在启动的时候根据service_counters 表创建 System.Diagnostics.PerformanceCounter class 的实例列表。 服务每隔一段时间收集一次性能计数器数据并把它存储到service_counter_snapshots 表。

所有的数据操作通过一个Restful服务接口DataCollectorController 进行操作。

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Net;

   5:  using System.Net.Http;

   6:  using System.Web.Http;

   7:  using PerformanceCounterCollect.Models;

   8:  using PerformanceCounterCollect.Web.Models;

   9:   

  10:  namespace PerformanceCounterCollect.Web.Controllers

  11:  {

  12:      public class DataCollectorController : ApiController

  13:      {

  14:          private ServiceCounterRepository scRepository;

  15:          private ServiceCounterSnapshotRepository scSnapshotReposity;

  16:   

  17:          public DataCollectorController()

  18:          {

  19:              scRepository = new ServiceCounterRepository();

  20:              scSnapshotReposity = new ServiceCounterSnapshotRepository();

  21:          }

  22:   

  23:          // GET api/values/5

  24:          [HttpGet]

  25:          public IEnumerable<ServiceCounter> SelectServiceCounter(string machineName)

  26:          {

  27:              return scRepository.SelectServiceCounter(machineName);

  28:          }

  29:   

  30:          // POST api/values

  31:          [HttpPost]

  32:          public IEnumerable<ServiceCounterSnapshot> SaveServiceSnapshots([FromBody]IEnumerable<ServiceCounterSnapshot> value)

  33:          {

  34:              return scSnapshotReposity.SaveServiceSnapshots(value);

  35:          }

  36:      }

  37:        

  38:  }

数据操作使用到了轻型的ORM类Dapper，使用了Repository模式。

   1:  using System;

   2:  using System.Data;

   3:  using System.Data.SqlClient;

   4:  using System.Linq;

   5:  using System.Web.Configuration;

   6:  using Dapper;

   7:   

   8:  namespace PerformanceCounterCollect.Web.Models

   9:  {

  10:      public abstract class BaseRepository

  11:      {

  12:          protected static void SetIdentity<T>(IDbConnection connection, Action<T> setId)

  13:          {

  14:              dynamic identity = connection.Query("SELECT @@IDENTITY AS Id").Single();

  15:              T newId = (T)identity.Id;

  16:              setId(newId);

  17:          }

  18:   

  19:          protected static IDbConnection OpenConnection()

  20:          {

  21:              IDbConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["SqlDiagnosticsDb"].ConnectionString);

  22:              connection.Open();

  23:              return connection;

  24:          }

  25:      }

  26:  }

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Web;
using Dapper;
using PerformanceCounterCollect.Models;


namespace PerformanceCounterCollect.Web.Models
{
    public class ServiceCounterRepository : BaseRepository
    {
        public IEnumerable<ServiceCounter> SelectServiceCounter(string machineName)
        {
            using (IDbConnection connection = OpenConnection())
            {
                string query = "select Id,ServiceName,CategoryName,CounterName,InstanceName from service_counters where MachineName=@MachineName";
                return connection.Query<ServiceCounter>(query, new { MachineName = machineName });
            }
        }


    }
}

 

 

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Web;
using Dapper;
using PerformanceCounterCollect.Models;

namespace PerformanceCounterCollect.Web.Models
{
    public class ServiceCounterSnapshotRepository: BaseRepository
    {
        public IEnumerable<ServiceCounterSnapshot> SaveServiceSnapshots(IEnumerable<ServiceCounterSnapshot> snapshots)
        {
            using (IDbConnection connection = OpenConnection())
            {
                foreach (var snapshot in snapshots)
                {
                    // insert new snapshot to the database
                    int retVal = connection.Execute(
    @"insert into service_counter_snapshots(ServiceCounterId,SnapshotMachineName,CreationTimeUtc,ServiceCounterValue) values (
        @ServiceCounterId,@SnapshotMachineName,@CreationTimeUtc,@ServiceCounterValue)", snapshot);
                    SetIdentity<int>(connection, id => snapshot.Id = id);
                }
            }
            return snapshots;
        }
    }
}

2、监控服务，也就是数据收集代理程序Monitoring Service：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Topshelf;
using Topshelf.Logging;

namespace PerformanceCounterCollect.Services
{
    class PerfmonWorker: ServiceControl
    {
        private readonly LogWriter logger = HostLogger.Get<PerfmonWorker>();
        public static bool ShouldStop { get; private set; }
        private ManualResetEvent stopHandle;

        public bool Start(HostControl hostControl)
        {
            logger.Info("Starting PerfmonWorker...");

            stopHandle = new ManualResetEvent(false);

            ThreadPool.QueueUserWorkItem(new ServiceMonitor().Monitor, stopHandle);

            return true;
        }

        public bool Stop(HostControl hostControl)
        {
            ShouldStop = true;
            logger.Info("Stopping PerfmonWorker...");
            // wait for all threads to finish
            stopHandle.WaitOne(ServiceMonitor.SleepIntervalInMilliSecs + 10);

            return true;
        }
    }

}

服务使用了Topshelf和NLog，具体参看《使用Topshelf 5步创建Windows 服务》。在服务启动的时候开启监控线程，执行方法ServiceMonitor.Monitor：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using PerformanceCounterCollect.Models;
using Topshelf.Logging;

namespace PerformanceCounterCollect.Services
{
    sealed class ServiceMonitor
    {
        public const int SleepIntervalInMilliSecs = 50000;

        private readonly LogWriter logger = HostLogger.Get<ServiceMonitor>();
        private IList<Tuple<int, PerformanceCounter>> serviceCounters;

        public void Monitor(object state)
        {
            ManualResetEvent stopHandle = (ManualResetEvent)state;
            String machineName = Environment.MachineName;
            try
            {
                Initialize(machineName);
                var snapshots = new ServiceCounterSnapshot[serviceCounters.Count];

                while (!PerfmonWorker.ShouldStop)
                {
                    Thread.Sleep(SleepIntervalInMilliSecs);

                    // this would be our timestamp value by which we will group the snapshots
                    DateTime timeStamp = DateTime.UtcNow;
                    // collect snapshots
                    for (int i = 0; i < serviceCounters.Count; i++)
                    {
                        var snapshot = new ServiceCounterSnapshot();
                        snapshot.CreationTimeUtc = timeStamp;
                        snapshot.SnapshotMachineName = machineName;
                        snapshot.ServiceCounterId = serviceCounters[i].Item1;
                        try
                        {
                            snapshot.ServiceCounterValue = serviceCounters[i].Item2.NextValue();
                            logger.DebugFormat("Performance counter {0} read value: {1}", GetPerfCounterPath(serviceCounters[i].Item2),
                                                snapshot.ServiceCounterValue);
                        }
                        catch (InvalidOperationException)
                        {
                            snapshot.ServiceCounterValue = null;
                            logger.DebugFormat("Performance counter {0} didn't send any value.", GetPerfCounterPath(serviceCounters[i].Item2));
                        }
                        snapshots[i] = snapshot;
                    }
                    SaveServiceSnapshots(snapshots);
                }
            }
            finally
            {
                stopHandle.Set();
            }
        }

        private void Initialize(String machineName)
        {
            try
            {
                var counters = new List<Tuple<int, PerformanceCounter>>();

                foreach (var counter in PerfmonClient.SelectServiceCounter(machineName))
                {
                    logger.InfoFormat(@"Creating performance counter: {0}\{1}\{2}\{3}", counter.MachineName ?? ".", counter.CategoryName,
                                        counter.CounterName, counter.InstanceName);
                    var perfCounter = new PerformanceCounter(counter.CategoryName, counter.CounterName, counter.InstanceName, counter.MachineName ?? ".");
                    counters.Add(new Tuple<int, PerformanceCounter>(counter.Id, perfCounter));
                    // first value doesn't matter so we should call the counter at least once
                    try { perfCounter.NextValue(); }
                    catch { }
                }


                serviceCounters = counters;
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }

        private void SaveServiceSnapshots(IEnumerable<ServiceCounterSnapshot> snapshots)
        {
            PerfmonClient.SaveServiceSnapshots(snapshots);
        }

        private String GetPerfCounterPath(PerformanceCounter cnt)
        {
            return String.Format(@"{0}\{1}\{2}\{3}", cnt.MachineName, cnt.CategoryName, cnt.CounterName, cnt.InstanceName);
        }
    }
}

在Monitor 方法中初始化完要采集的性能计数器实例后开启一个主循环，定期的收集数据，如果相关的性能计数器实例没有运行，计数器将会抛出InvalidOperationException 我们就把它设置为null。数据集的数据通过WebAPI发回服务器端存储，这样就可以实现性能计数器的集中存储了。

3、使用方法

使用很简单，首先定义我们要收集的数据

insert into services values ('notepad', 'notepad process test');

insert into service_counters values ( 'notepad', ‘GEFFZHANG-PC’, 'process', '% Processor Time', 'notepad', null, 'graph');

insert into service_counters values ( 'notepad', ‘GEFFZHANG-PC’, 'process', 'working set', 'notepad', null, 'graph');

然后启动我们的性能计数器收集服务

代码参见项目 https://github.com/geffzhang/PerformanceCounterCollect/

WMI Performance Counter Logging Console App