- Added ComputerName and Address to the config. (#138)

- Updated the TabMon.config file to reflect the changes.
- Updated CounterSampler to use the address when databasing value.
- Updated host object to use both the address and computer name. This change is reflected in ToString().
- Updated perfmon code to refer to the computer name.
- Updated JMX code to refer to the address.
- Refactored the PerfmonCounterConfigReader class to make it more readable, skip the collection of PerfMon counters on incorrect computer names, and make the errors more readable.
- Removed the HostNameHelper since the computer name and address are now manually configured.

TabMon/Config/TabMon.config

@@ -8,7 +8,7 @@
   <!-- Target cluster & host configuration -->
   <Clusters>
     <Cluster name="Primary">
-      <Host name="localhost"/>
+      <Host computerName="YOURCOMPUTERNAME" address="localhost"/>
     </Cluster>
   </Clusters>
   <!-- Results output database Configuration-->

TabMon/CounterConfig/CounterConfigLoader.cs

@@ -20,7 +20,7 @@ internal static class CounterConfigLoader
         private const string PathToCountersConfig = @"Config\Counters.config";
         private const string PathToSchema = @"Resources\CountersConfig.xsd";
         private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private static XmlDocument loadedConfigDocument; 
+        private static XmlDocument loadedConfigDocument;
 
         /// <summary>
         /// Loads the Counters.config file, validates it against the XSD schema, and news up the appropriate CounterConfigReader object for each root counter type node.
@@ -54,7 +54,7 @@ public static ICollection<ICounter> Load(IEnumerable<Host> hosts, CounterLifecyc
                     if (countersInNode.Count > 0)
                     {
                         Log.DebugFormat("Loaded {0} {1} {2} {3} on {4}.",
-                                        countersInNode.Count, counterLifecycleType.ToString().ToLowerInvariant(), counterType, "counter".Pluralize(countersInNode.Count), host.Name);
+                                        countersInNode.Count, counterLifecycleType.ToString().ToLowerInvariant(), counterType, "counter".Pluralize(countersInNode.Count), host.Address);
                         counters.AddRange(countersInNode);
                     }
                 }

TabMon/CounterConfig/MBeanCounterConfigReader.cs

@@ -43,7 +43,7 @@ public ICollection<ICounter> LoadCounters(XmlNode root, Host host, CounterLifecy
 
                     // Retrieve a collection of all available clients within the specified port range, then new up counters using those.
                     // This way, multiple counters can share a single client & connection.
-                    var mbeanClientPool = MBeanClientFactory.CreateClients(host.Name, startPort, endPort);
+                    var mbeanClientPool = MBeanClientFactory.CreateClients(host.Address, startPort, endPort);
                     foreach (var mbeanClient in mbeanClientPool)
                     {
                         var countersForSource = BuildCountersForSourceNode(sourceNode, host, mbeanClient, startPort);
@@ -123,7 +123,7 @@ private static ICounter BuildCounterFromCounterNode(XmlNode counterNode, IMBeanC
             catch (Exception ex)
             {
                 Log.DebugFormat(@"Failed to register MBean counter {0}\{1}\{2}\{3}\{4}: {5}",
-                                host.Name, sourceName, categoryName, counterName, instanceName, ex.Message);
+                                host.Address, sourceName, categoryName, counterName, instanceName, ex.Message);
                 return null;
             }
         }

TabMon/CounterConfig/PerfmonCounterConfigReader.cs

@@ -1,7 +1,9 @@
-using System;
+using log4net;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Reflection;
 using System.Xml;
 using TabMon.Counters;
 using TabMon.Counters.Perfmon;
@@ -14,6 +16,8 @@ namespace TabMon.CounterConfig
     /// </summary>
     internal sealed class PerfmonCounterConfigReader : ICounterConfigReader
     {
+        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         /// <summary>
         /// Parses & loads all Perfmon counters for the given host using the XML tree.
         /// </summary>
@@ -26,47 +30,63 @@ public ICollection<ICounter> LoadCounters(XmlNode root, Host host, CounterLifecy
             var counters = new Collection<ICounter>();
             var perfmonCounterNodes = root.SelectNodes("./*/Counter");
 
-            foreach (XmlNode counterNode in perfmonCounterNodes)
+            try
             {
-                // Set what we know.
-                var counterName = counterNode.Attributes["name"].Value;
-                var categoryName = counterNode.ParentNode.Attributes["name"].Value;
-                string unitOfMeasurement = null;
-                if (counterNode.Attributes.GetNamedItem("unit") != null)
+                foreach (XmlNode counterNode in perfmonCounterNodes)
                 {
-                    unitOfMeasurement = counterNode.Attributes["unit"].Value;
+                    counters.AddRange(LoadCountersForNode(counterNode, host, lifeCycleTypeToLoad));
                 }
+            }
+            catch (System.IO.IOException ex)
+            {
+                Log.ErrorFormat("Unable to load PerfMon counters for host {0}: {1}Please verify that the computer name is configured correctly.", host, ex.Message);
+            }
+
+            return counters;
+        }
+
+        private ICollection<ICounter> LoadCountersForNode(XmlNode counterNode, Host host, CounterLifecycleType lifeCycleTypeToLoad)
+        {
+            var counters = new Collection<ICounter>();
+
+            // Set what we know.
+            var counterName = counterNode.Attributes["name"].Value;
+            var categoryName = counterNode.ParentNode.Attributes["name"].Value;
+            string unitOfMeasurement = null;
+            if (counterNode.Attributes.GetNamedItem("unit") != null)
+            {
+                unitOfMeasurement = counterNode.Attributes["unit"].Value;
+            }
 
-                // If any instance names are called out, shove them into a list of filters.
-                var instanceFilters = new HashSet<string>();
-                if (counterNode.HasChildNodes)
+            // If any instance names are called out, shove them into a list of filters.
+            var instanceFilters = new HashSet<string>();
+            if (counterNode.HasChildNodes)
+            {
+                var instanceNodes = counterNode.SelectNodes("./Instance");
+                if (instanceNodes == null)
                 {
-                    var instanceNodes = counterNode.SelectNodes("./Instance");
-                    if (instanceNodes == null)
-                    {
-                        continue;
-                    }
+                    return counters;
+                }
 
-                    foreach (var instanceNode in instanceNodes.Cast<XmlNode>().Where(instanceNode => instanceNode.Attributes.GetNamedItem("name") != null))
+                foreach (var instanceNode in instanceNodes.Cast<XmlNode>().Where(instanceNode => instanceNode.Attributes.GetNamedItem("name") != null))
+                {
+                    string instanceName = instanceNode.Attributes["name"].Value;
+                    CounterLifecycleType configuredCounterLifecycleType = GetConfiguredInstanceLifecycleType(instanceNode);
+                    if (configuredCounterLifecycleType == lifeCycleTypeToLoad)
                     {
-                        string instanceName = instanceNode.Attributes["name"].Value;
-                        CounterLifecycleType configuredCounterLifecycleType = GetConfiguredInstanceLifecycleType(instanceNode);
-                        if (configuredCounterLifecycleType == lifeCycleTypeToLoad)
-                        {
-                            instanceFilters.Add(instanceName);
-                        }
+                        instanceFilters.Add(instanceName);
                     }
                 }
+            }
 
-                // Load an instance of this perfmon counter for each matching instance name that exists.
-                // If no instance name is specified, just load them all.
-                if (lifeCycleTypeToLoad == CounterLifecycleType.Persistent || instanceFilters.Count > 0)
+            // Load an instance of this perfmon counter for each matching instance name that exists.
+            // If no instance name is specified, just load them all.
+            if (lifeCycleTypeToLoad == CounterLifecycleType.Persistent || instanceFilters.Count > 0)
+            {
+                var counterInstances = PerfmonCounterLoader.LoadInstancesForCounter(host, lifeCycleTypeToLoad, categoryName, counterName, unitOfMeasurement, instanceFilters);
+                foreach (var counterInstance in counterInstances)
                 {
-                    var counterInstances = PerfmonCounterLoader.LoadInstancesForCounter(host, lifeCycleTypeToLoad, categoryName, counterName, unitOfMeasurement, instanceFilters);
-                    foreach (var counterInstance in counterInstances)
-                    {
-                        counters.Add(counterInstance);
-                    }
+                    counters.Add(counterInstance);
                 }
             }
 

TabMon/Counters/Perfmon/PerfmonCounter.cs

@@ -38,7 +38,7 @@ public PerfmonCounter(Host host, CounterLifecycleType lifecycleType, string coun
             Counter = counterName;
             Instance = instance;
             Unit = unit;
-            perfmonCounter = new PerformanceCounter(Category, Counter, Instance, Host.Name);
+            perfmonCounter = new PerformanceCounter(Category, Counter, Instance, Host.ComputerName);
         }
 
         ~PerfmonCounter()

TabMon/Counters/Perfmon/PerfmonCounterLoader.cs

@@ -32,22 +32,22 @@ public static IList<PerfmonCounter> LoadInstancesForCounter(Host host, CounterLi
             IList<PerfmonCounter> counters = new List<PerfmonCounter>();
 
             // If the requested category does not exist, log it and bail out.
-            if (!ExistsCategory(categoryName, host.Name))
+            if (!ExistsCategory(categoryName, host.ComputerName))
             {
                 Log.WarnFormat("PerfMon counter category '{0}' on host '{1}' does not exist.",
-                                categoryName, host.Name);
+                                categoryName, host.ComputerName);
                 return counters;
             }
 
             // If the requested counter does not exist, log it and bail out.
-            if (!ExistsCounter(counterName, categoryName, host.Name))
+            if (!ExistsCounter(counterName, categoryName, host.ComputerName))
             {
                 Log.DebugFormat("PerfMon counter '{0}' in category '{1}' on host '{2}' does not exist.",
-                                counterName, categoryName, host.Name);
+                                counterName, categoryName, host.ComputerName);
                 return counters;
             }
 
-            var category = new PerformanceCounterCategory(categoryName, host.Name);
+            var category = new PerformanceCounterCategory(categoryName, host.ComputerName);
 
             // Perfmon has both "single-instance" and "multi-instance" counter types -- we need to handle both appropriately.
             switch (category.CategoryType)
@@ -65,7 +65,7 @@ public static IList<PerfmonCounter> LoadInstancesForCounter(Host host, CounterLi
                     }
                     break;
                 default:
-                    Log.ErrorFormat("Unable to determine category type of PerfMon counter '{0}' in category '{1}' on host '{2}' is unknown; skipping loading it.", counterName, categoryName, host.Name);
+                    Log.ErrorFormat("Unable to determine category type of PerfMon counter '{0}' in category '{1}' on host '{2}' is unknown; skipping loading it.", counterName, categoryName, host.ComputerName);
                     break;
             }
 

TabMon/Helpers/Host.cs

@@ -5,18 +5,20 @@
     /// </summary>
     public sealed class Host
     {
-        public string Name { get; private set; }
+        public string Address { get; private set; }
+        public string ComputerName { get; private set; }
         public string Cluster { get; private set; }
 
-        public Host(string name, string cluster)
+        public Host(string address, string computerName, string cluster)
         {
-            Name = name;
+            Address = address;
+            ComputerName = computerName;
             Cluster = cluster;
         }
 
         public override string ToString()
         {
-            return Cluster + "\\" + Name;
+            return Cluster + "\\" + Address + "\\" + ComputerName;
         }
     }
 }

TabMon/Resources/TabMonConfig.xsd

@@ -87,7 +87,12 @@
 		</xs:attribute>
 	</xs:complexType>
 	<xs:complexType name="TabMon.Config.HostCT">
-		<xs:attribute name="name" use="required" type="xs:string">
+		<xs:attribute name="computerName" use="required" type="xs:string">
+			<xs:annotation>
+				<xs:documentation>The computer name of the host to monitor.</xs:documentation>
+			</xs:annotation>
+		</xs:attribute>
+		<xs:attribute name="address" use="required" type="xs:string">
 			<xs:annotation>
 				<xs:documentation>The hostname or IP address of the host to monitor.</xs:documentation>
 			</xs:annotation>

TabMon/Sampler/CounterSampler.cs

@@ -150,7 +150,7 @@ private static DataRow MapToSchema(ICounterSample sample, DataTable tableSchema,
             var counter = sample.Counter;
             row["timestamp"] = pollTimestamp;
             row["cluster"] = counter.Host.Cluster;
-            row["machine"] = counter.Host.Name.ToLower();
+            row["machine"] = counter.Host.Address;
             row["counter_type"] = counter.CounterType;
             row["source"] = counter.Source;
             row["category"] = counter.Category;

TabMon/TabMon.csproj

@@ -147,7 +147,6 @@
     <Compile Include="TabMonConfig\TabMonConfigReader.cs" />
     <Compile Include="TabMonConfig\TabMonConfigSection.cs" />
     <Compile Include="TabMonOptions.cs" />
-    <Compile Include="Helpers\HostnameHelper.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="Config\TabMon.config">

TabMon/TabMonConfig/TabMonConfigReader.cs

@@ -73,8 +73,7 @@ public static void LoadOptions()
                     var clusterName = cluster.Name;
                     foreach (Host host in cluster)
                     {
-                        var resolvedHostname = HostnameHelper.Resolve(host.Name);
-                        options.Hosts.Add(new Helpers.Host(resolvedHostname, clusterName));
+                        options.Hosts.Add(new Helpers.Host(host.Address, host.ComputerName, clusterName));
                     }
                 }
             }