• Windows performance logs

• Windows event logs

• SQL Server Profiler traces

• SQL Server blocking information

• SQL Server configuration information

It is a utility coming with SQL Server installation by default. And the default path for the exe file is C:\Program Files\Microsoft SQL Server\110\Tools\Binn for SQL 2012. For the first time please just run the exe to create necessary files and folders:

Wait until you see the green line and press Ctrl+C.

Under Binn folder, there is a new file created called SD_Detailed.xml which is used to configure which issues to collect. This file can be copied and the new file can be edited to keep the default configuration file as it is. I have just copied it and renamed the new file as SD_Detailed_test.xml. And just edited ShowPlan All event as true to be able to view query plans of the collected trace. Please be careful in your live systems with the expected performance impact of ShowPlan All event. 

The next step is running the sqldiag utility with the recently configured file properties. To be able to run SQLDiag with the new input file, I have used /I parameter. For the set of parameters please review: https://technet.microsoft.com/en-us/library/ms162833(v=sql.110).aspx 

It will ask you to overwrite the output folder, I have just type "Y" in my case. With the green line, it will warn you when it starts to collect data. I have run a workload here to have more meaningful data but in your live systems you will have already meaningful workloads :) 

All collected data will be stored under C:\Program Files\Microsoft SQL Server\110\Tools\Binn\SQLDIAG folder:

--Files with .trc extensions are the sql profiler trace file giving information to analyze queries.

--Files with .blg extensions are the performance monitor files giving information about the configured performance counters.

--File with .log extention shows the error log information.

--File having "ms_info32.txt" in its name, shows system configuration information.

Now, we have collected many data to be analyzed, analyzing by eye and each file one by one could be an option of course however it could be a waste of time. 

I will write about analyzing tools in my next blog posts. please hold the line :) 

Işıl

We are going to visualize our results now. How? We are going to use Reporting Services. If you are not familiar please don’t worry, just follow.

If you don’t have reporting services installed, you should do it first.

BE CAREFUL, I am going to install it on central management server, but it is not a must.

I just run the sqlserver setup.exe and followed the usual steps until “Installation Type” dialog. On Installation Type dialog, please select add features and related instance:

https://msdn.microsoft.com/en-us/library/ms159624.aspx

The next step is configuring Reporting Services from Reporting Service Configuration Manager: https://technet.microsoft.com/en-us/library/ms159644(v=sql.105).aspx

After clicking https://ISILEFE03/80 /Reports, you should have a website like the one below:

And now time is deploying reports. Under C:\Users\isilefe\Downloads\CodePlex 3.0.zip\CodePlex 3.0 folder, there exists 2Reporting folder. This is a bunch of rdl’s wrapped as a project solution. After opening this solution via BIDS or Visual Studio, you should edit data source first:

As a last step, we can deploy reports now. Firstly, we should edit the path of url under properties of project solution:

And the just right click the PolicyReports solution name and click deploy.

And now, we can check the reports from the browser: 

And here is an example dashboard report where you can drill down to other reports and details of failed policies.

And as a command you should type the same command as you configured before according to the instructions in my 2^nd blog post in these series.

As a result you should have a dialog similar to the one below:

And as a last step, please don’t forget to define a schedule. I just configured it to run once a day except working hours.

Lastly, don’t forget to test your job not to hit any syntax or permission issue. 

To collect results, firstly of course we need a database. But, don’t worry about that actually it is the easiest part since we have a ready script for that. The only thing you need to do is downloading EPMFramework from the link https://epmframework.codeplex.com/releases/view/28621 I haven’t changed the default download path and have just gone to C:\Users\isilefe\Downloads\CodePlex 3.0.zip\CodePlex 3.0\0Setup Scripts and opened EPM_Create_Database_Objects.sql script.

And now, you should configure the variables below according to your environment.

:SETVAR ServerName "ISILEFE02" – ISILEFE02 is the name of central management server in my environment

:SETVAR ManagementDatabase "PSDatabase" – PSDatabase is the name of the database that I am going to use, it could be either and existing one or a new one, I just preferred a new one.

GO 

After changing these two variables, you can run the script in SQL CMD mode. 

Now, our database is ready to store the data.

The next step is collecting data:

It is also an easy step since we have a ready powershell script. Don’t worry if you are not familiar with PowerShell, you can just review my blogpost https://blogs.msdn.com/b/isilefe/archive/2012/07/23/how-to-manage-your-sql-servers-with-powershell.aspx to understand the logic better.

I could find the downloaded script under C:\Users\isilefe\Downloads\CodePlex 3.0.zip\CodePlex 3.0\1Down Version Evaluation PS. Firstly, you should edit this script in notepad, by declaring centralmanagement server name, database name. and also you should define a results directory.

# Declare variables to define the central warehouse

# in which to write the output, store the policies

$CentralManagementServer = "ISILEFE02"

$HistoryDatabase = "PSDatabase"

# Define the location to write the results of the

# policy evaluation.  Delete any files in the directory.

$ResultDir = "c:\Results\"

And now, the thing to do is just going to SSMS and right click on your central management server name and choose StartPowershell to try if the script can be run successfully.

The script asks for configuration group and category filter as a parameter, to be able to run the script in all configuration groups and for all categories, I made a small edit in the “parameters” part as seen below:

# Uses the Invoke-PolicyEvaluation Cmdlet

#param([string]$ConfigurationGroup=$(Throw `

#"Paramater missing: -ConfigurationGroup ConfigGroup"),`

#[string]$PolicyCategoryFilter=$(Throw "Parameter missing: `

#-PolicyCategoryFilter Category"), `

#[string]$EvalMode=$(Throw "Parameter missing: -EvalMode EvalMode"))

[string]$ConfigurationGroup=""

[string]$PolicyCategoryFilter=""

[string]$EvalMode="check"

And now you can run the script without any parameters, if you would like to define categories and configuration group you can use the original script and run the script by passing parameters:

SL "C:\Users\isilefe\Downloads\CodePlex 3.0\CodePlex 3.0"

.\EPM_EnterpriseEvaluation_3.0.0.ps1 -ConfigurationGroup

After you press “Enter” you see informational text as below meaning that you successfully run your policies:

And now, let’s check if we have the data in our database. I have just run the scripts below on my central management server:

select * from PSDatabase.[policy].[v_PolicyHistory]

select * from PSDatabase.[policy].[v_PolicyHistory_LastEvaluation]

So far so good, I can see the results of evaluated policies for my both sql instances that I have registered under Central Management Server.

However, still not perfect J Why not?

Since I don’t want to run policies each and every time manually. How to automate it? Please review my next blog post on this topic.

Let’s start with Central Management Server which is a feature coming with SQL 2008. https://technet.microsoft.com/en-us/library/bb934126(v=sql.100).aspx (But don’t worry if you still have SQL servers older than 2008. You can still register them under a central management server whose version is 2008. )

CMS is mainly used for running a query or a policy on more than one SQL Server instances at the same time. Registering is very straightforward in fact. Please just follow the steps below:

1. In SQL Server Management Studio, on the View menu, click Registered Servers.
2. In Registered Servers, expand Database Engine, right-click Central Management Servers, point to New, and then click Central Management Servers.
3. In the New Server Registration dialog box, register the instance of SQL Server that you want to become the Central Management Server.
4. In Registered Servers, right-click the Central Management Server, point to New, and then click New Server Group. Type a group name and description, and then click OK.
5. In Registered Servers, right-click the Central Management Server group, and then click New Server Registration.
6. In the New Server Registration dialog box, register one or more instances of SQL Server that you want to become members of the server group.

After registering your central management server, you can register a group (for ex you can group according to versions) or you can directly register a SQL instance under your central management server. I have chosen the 2^nd option and skipped 4 define above. As a result you should have sth like the one below:

BE CAREFUL that only Windows authentication is permitted. 

And now, let’s talk about Policy Based Management and then combine these two together. I am not going to go into detail with Policy Based Management Server, you can review the link for details. https://technet.microsoft.com/en-us/library/bb510667.aspx

Let me give you an example,

Our policy: A database has a full backup since yesterday.

If you evaluate this policy against a SQL instance, if you have a database that you have full backup older than yesterday, then the policy will be evaluated.

You can check many things from data-file location to your db options with policies. You can write your own policies even with your custom script, however not to go away from our main topic I will work with standard policies coming with SQL Server installation. When you expand Management branch on SSMS, you have a branch called “Policy Management”. To be able to use standard policies we have to import first. Please review the screen shot below: 

After importing the policy, we can now evaluate it and see the results.

So far so good, right? But what if I have dozens of SQL instances and I want to evaluate a policy on all SQL instances at the same time?

Now, it is time to combine CMS and Policy Based Management together:

Just right click Registered Servers > Central Management Server > ISILEFE02 and then click import policies:

And import “Last Successful Backup Date” policy:

And here you go, just evaluate it and see your results on all SQL instances under your Central Management Server!

OK so far so good but still not perfect. Why not?

We can view the results by run time, what if we collected the results in a database regularly by a scheduled agent job and view the results via reports. It would be great, right?

And it is not that much work, please review my next blog post in this series.

The basic idea of a server cluster is physical servers acting as a virtual server, so  it is critical that each of the physical servers have a consistent view of how the cluster is configured. Quorum acts as a definitive repository for the configuration information of physical clusters. When network problems occur, they can interfere with communication between cluster nodes. A small set of nodes might be able to communicate together across a functioning part of a network but not be able to communicate with a different set of nodes in another part of the network. In that case, the quorum is used to guarantee that any cluster resource is only brought online on only one node.

In other words, the quorum configuration determines the number of failures that the cluster can sustain. If an additional failure occurs, the cluster must stop running. The relevant failures in are failures of nodes or, in some cases, of a disk witness (which contains a copy of the cluster configuration) or file share witness. It is essential that the cluster stop running if too many failures occur or if there is a problem with communication between the cluster nodes.

Windows 2003 :

Local Quorum: This cluster model is for clusters that consist of only one node. This model is also referred to as a local quorum. It is typically used for:

• Deploying dynamic file shares on a single cluster node, to ease home directory deployment and administration.
• Testing.
• Development.

Standard Quorum: A standard quorum uses a quorum log file that is located on a disk hosted on a shared storage interconnect that is accessible by all members of the cluster. In this configuration, quorum disk should be online in order to provide cluster to be online.

The following diagram is an example of standard quorum for a 4-node cluster, referencing https://technet.microsoft.com/en-us/library/cc779076(v=ws.10).aspx

,

Majority Node Set:  For this type, the data is actually stored by default on the system disk of each member of the cluster. The MNS resource takes care to ensure that the cluster configuration data stored on the MNS is kept consistent across the different disks. The cluster service itself will only start up and therefore bring resources online if a majority of the nodes configured as part of the cluster are up and running the cluster service.

The number of nodes is important to decide which model to use, for example for a 2-node failover cluster, MNS model is not recommended since when one of the nodes is unavailable it will cause the cluster to be offline. For a 2-node cluster, standard quorum model is recommended.

Note that MNS only removes the requirement for shared disk only for the quorum requirement, for example if you are using SQL Server Failover Cluster you still require shared storage to keep data.

Window 2008 – Windows 2008 R2:

Note that for Windows 2003 clusters either each node can have a vote, and if majority of nodes are online, cluster will sustain or a shared disk can be used to decide if the cluster will sustain or not..  

For Windows 2008-Windows 2008 R2 cluster, standard quorum model is still an option, as listed no majority- disk only below. Other options are based on providing majority of votes. For the quorum configuration, each node, shared disk or a file share can have a vote. And as best practice, it is recommended to have an odd number nodes in total, for example if you have 5 nodes, node majority is recommended, however if you have 4 nodes it is not a good idea to use node majority since total number of votes is four and when 2 nodes are unavailable, the cluster will stop. If you use 1 more vote (could be a shared disk), then the cluster will sustain for 2 nodes failure since 2 nodes + 1 shared disk will have totally 3 votes which is enough to sustain cluster.

All modes for Windows 2008 clusters can be summarized as below referencing https://technet.microsoft.com/en-us/library/cc731739.aspx#BKMK_how.

Node Majority (recommended for clusters with an odd number of nodes)

Can sustain failures of half the nodes (rounding up) minus one. For example, a seven node cluster can sustain three node failures.

Node and Disk Majority (recommended for clusters with an even number of nodes)

Can sustain failures of half the nodes (rounding up) if the disk witness remains online. For example, a six node cluster in which the disk witness is online could sustain three node failures.

Can sustain failures of half the nodes (rounding up) minus one if the disk witness goes offline or fails. For example, a six node cluster with a failed disk witness could sustain two (3-1=2) node failures.

Node and File Share Majority (for clusters with special configurations)

Works in a similar way to Node and Disk Majority, but instead of a disk witness, this cluster uses a file share witness.

Note that if you use Node and File Share Majority, at least one of the available cluster nodes must contain a current copy of the cluster configuration before you can start the cluster. Otherwise, you must force the starting of the cluster through a particular node. For more information, see "Additional considerations" in Start or Stop the Cluster Service on a Cluster Node.

No Majority: Disk Only (not recommended)

Can sustain failures of all nodes except one (if the disk is online). However, this configuration is not recommended because the disk might be a single point of failure.

Node Vote Assignment Enhancement: By default, all nodes are assigned votes. With the hotfix https://support.microsoft.com/kb/2494036 for Windows 2008 and Windows 2008 R2, removing vote of a node is an option to choose as an advanced quorum option. All nodes continue to function in the cluster, receive cluster database updates, and can host applications either it has vote or not.

In certain disaster recovery scenarios, it may be required to remove votes from nodes.  For example, in a multisite cluster, you could remove votes from the nodes in a backup site so that those nodes do not affect quorum calculations. This configuration is recommended only for manual failover across sites. 

In Windows 2008 and Windows 2008R2, removing vote from nodes is only possible with powershell commands as described in hotfix article above.

Note that Node vote assignment is not recommended to enforce an odd number of voting nodes. Instead, a disk witness or file share witness should be configured.

Windows 2012:

The quorum models are the same in Windows 2012 like Windows 2008 R2, however there are enhancements with Node Vote Assignment and there is a new concept called as “Dynamic Quorum Configuration”. 

Node Vote Assignment Enhancement:

Node vote assignment could be done only with Powershell commands in Windows 2008 or 2008 R2. Starting with Windows 2012, it can be done via Failover Cluster Manager:

Dynamic Quorum Configuration:

Starting Windows Server 2012, there is a new concept called dynamic quorum configuration. This concept is based on node vote assignment, specifically it relies on the fact that cluster can manage node vote assignment automatically based on the state of each node.  Votes are automatically removed from nodes that leave active cluster membership, and a vote is automatically assigned when a node rejoins the cluster. By default, dynamic quorum management is enabled.

This is a huge improvement as it is possible to continue to run a cluster even if the number of nodes remaining in the cluster is less than 50%.

By dynamic quorum configuration, quorum is calculated according to majority of active nodes since the nodes that are unavailable has no votes. With dynamic quorum management, it is also possible for a cluster to run on the last surviving cluster node.

With Get-ClusterNode Windows PowerShell cmdlet, it can be determined if a node has vote or not. A value of 0 indicates that the node does not have a quorum vote. A value of 1 indicates that the node has a quorum vote.

The vote assignment for all cluster nodes can be verified by using the Validate Cluster Quorum validation test.

Note that the vote of a node is removed expilicitly, the cluster cannot dynamically add or remove that vote.

Note that if you have 2 remaining nodes, the cluster will sustain with a possibility of  %50  or will go down with a possibility of  %50. (randomly chosen) This drawback has been resolved in Windows 2012 R2, see in Dynamic Witness part.

Windows 2012 R2:

In Windows 2012 R2 there are new enhancements on top of node vode assignment and dynamic quorum configuration.

Quorum Userinterface Improvement:

The assigned node vote values can be seen from UI starting with Windows Server 2012 R2:

Dynamic Quorum Enhancements:

1. 1.       Force Quorum Resiliency:

If there is a partitioned cluster in Windows Server 2012, after connectivity is restored, you must manually restart any partitioned nodes that are not part of the forced quorum subset with the /pq switch to prevent quorum. Ideally, you should do this as quickly as possible.

In Windows Server 2012 R2, both sides have a view of cluster membership and they will automatically reconcile when connectivity is restored. The side that you started with force quorum is deemed authoritative and the partitioned nodes automatically restart with the /pq switch to prevent quorum.

1. 2.       Dynamic Witness:

In Windows Server 2012 R2, the cluster is configured to use dynamic quorum configuration by default, in addition to that, the witness vote is also dynamically adjusted based on the number of voting nodes in current cluster membership. If there are an odd number of votes, the quorum witness does not have a vote. If there is an even number of votes, the quorum witness has a vote. The quorum witness vote is also dynamically adjusted based on the state of the witness resource. If the witness resource is offline or failed, the cluster sets the witness vote to "0."

Dynamic witness significantly reduces the risk that the cluster will go down because of witness failure. The cluster decides whether to use the witness vote based on the number of voting nodes that are available in the cluster.

Note that if you have 2 remaining nodes in a cluster in Windows 2012, if 1 node is unavailable the cluster will be online with %50 possibility. With starting Windows 2012 R2, it is guaranteed to sustain cluster by the help of  “dynamic witness” concept.

This change also greatly simplifies quorum witness configuration. You no longer have to determine whether to configure a quorum witness because the recommendation in Windows Server 2012 R2 is to always configure a quorum witness. The cluster automatically determines when to use it.

1. 3.       Tie-breaker for %50 Node Split:

 Referencing : https://technet.microsoft.com/en-us/library/dn265972.aspx#BKMK_FQ

Starting with Windows 2012 R2,  a cluster can dynamically adjust a running node's vote to keep   the total number of votes at an odd number. This functionality works seamlessly with dynamic witness. To maintain an odd number of votes, a cluster will first adjust the quorum witness vote through dynamic witness. However, if a quorum witness is not available, the cluster can adjust a node's vote. For example:

1. You have a six node cluster with a file share witness. The cluster stretches across two sites with three nodes in each site. The cluster has a total of seven votes.
2. The file share witness fails. Because the cluster uses dynamic witness, the cluster automatically removes the witness vote. The cluster now has a total of six votes.
3. To maintain an odd number of votes, the cluster randomly picks a node to remove its quorum vote. One site now has two votes, and the other site has three.
4. A network issue disrupts communication between the two sites. Therefore, the cluster is evenly split into two sets of three nodes each. The partition in the site with two votes goes down. The partition in the site with three votes continues to function.

• In Windows Server 2012, in the scenario above both sides will go down if there is a 50% split where neither site has quorum, both sides will go down.
• In Windows Server 2012 R2, LowerQuorumPriorityNodeID cluster common property can be assigned to a cluster node in the secondary site so that the primary site stays running. Set this property on only one node in the site.

 declare @minstarttime datetime
 declare @duration int
 select @minstarttime=min(start_time) from sys.dm_exec_requests where session_id>50
 --select getdate()
 --select @minstarttime
 select @duration=datediff (s, @minstarttime, getdate())
 --select @duration
 if(@duration > 60)
 select r.session_id, t.text, x.login_name, x.program_name, datediff(s, start_time, getdate()) as durationSec, p.query_plan
 --cross apply sys.dm_exec_sql_text (sql_handle)
 from sys.dm_exec_requests r with (nolock) 
 cross apply sys.dm_exec_sql_text(sql_handle) t 
 cross apply sys.dm_exec_query_plan(plan_handle) p 
 inner join sys.dm_exec_sessions x on r.session_id = x.session_id 
 inner join sys.dm_exec_connections c on c.session_id = x.session_id 
 where datediff(s, start_time, getdate()) > 60
 order by datediff(s, start_time, getdate()) desc

If you have queries running more than 60 secs, the result will be sth similar to the below:

After configuring DB mail, you can run a script which is similar to below in every 60 seconds via SQL Agent job, and then you will be alarmed if you have queries running longer than 60 seconds, that's all!

Within the script, sp_send_dbmail stored procedure is used to send an email. With @tableHTML variable, the T-SQL script is used to detect queries running more than 60 seconds and @recipients variable shows the recipient email address.

declare @minstarttime datetime
 declare @duration int
 select @minstarttime=min(start_time) from sys.dm_exec_requests where session_id>50
 select @duration=datediff (s, @minstarttime, getdate())
 
 if(@duration > 60)
 begin
 declare @tableHTML NVARCHAR(MAX) 
 SET @tableHTML =
 N'Hello;<br/><br/> On the X server, queries running longer than 60 seconds:<br/>'+
 N'<table style="border-collapse:collapse;font-size:10pt;white-space:nowrap;" border="1" cellpadding="10">' +
 N'<tr bgcolor="#D6D9E0"><td>session_id</td><td>login_name</td><td>sql_text</td><td>program_name</td><td>Second_Duration</td>' +
 N'<td>query_plans</td></tr>' +
 CAST ( ( select 
 td = r.session_id,'',
 td = x.login_name,'',
 td = t.text,'',
 td = x.program_name,'',
 td = datediff(s, start_time, getdate()),'',
 td = p.query_plan,''
 from sys.dm_exec_requests r with (nolock) 
 cross apply sys.dm_exec_sql_text(sql_handle) t 
 cross apply sys.dm_exec_query_plan(plan_handle) p 
 inner join sys.dm_exec_sessions x on r.session_id = x.session_id 
 inner join sys.dm_exec_connections c on c.session_id = x.session_id 
 where datediff(s, start_time, getdate()) > 60
 order by datediff(s, start_time, getdate()) desc
 FOR XML PATH('tr'), TYPE ) AS NVARCHAR(MAX) ) + N'</table>' ;
 
 EXEC msdb.dbo.sp_send_dbmail
 @recipients = 'recipient@xmail.com',
 @subject = 'Queries Running Longer Than 60 Seconds',
 @body = @tableHTML,
 @importance = 'HIGH',
 @body_format = 'HTML' ; 
 
 
 end
 
 
 

I will create this demo on SQL 2012 SP1 running on Windows 8.1. As a prerequisite, I will set PowerShell execution policy to RemoteSigned with the script:

Set-ExecutionPolicy RemoteSigned

Firstly I will create 3 txt files called AllServers.txt, status.txt and status_error.txt under the path C:\control_scripts as shown below:

Status.txt and status_error.txt files will be empty. In AllServes.txt file, there will be list of servers you want to monitor. Please write the host names which SQL Servers are running on. As a test environment, I am using only one server, but will write the hostname two times to confirm that my code can be run on multiserver environment:

Now, it is time to write the PowerShell script:

I will write the code in 3 basic parts, the first part of the code is a function which get all SQL instances for a server. The second part of the code will monitor SQL services and the last part will monitor the databases for all servers.

#Here is the first part of the code, referring PowerShell magazine here: 
 #https://www.powershellmagazine.com/2013/08/06/pstip-retrieve-all-sql-instance-names-on-local-and-remote-computers 
 #I will use this function in the 3rd part of the code to access the SQL instances to be able to check database status.
 
 Function Get-SQLInstance {
 
 param (
 [string]$ComputerName = $env:COMPUTERNAME,
 [string]$InstanceName
 )
 
 
 try {
 $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('LocalMachine', $ComputerName)
 $regKey= $reg.OpenSubKey("SOFTWARE\\Microsoft\\Microsoft SQL Server\\Instance Names\\SQL" )
 $instances = $regkey.GetValueNames()
 
 if ($InstanceName) {
 if ($instances -contains $InstanceName) {
 return $true
 } else {
 return $false
 }
 } else {
 $instances
 }
 }
 catch {
 Write-Error $_.Exception.Message
 return $false
 }
 } 
 
 #I am getting the list of all SQL Servers with the following code:

 $servers = @(get-content "C:\control_scripts\AllServers.txt" -TotalCount 2)
 
 #The code below is doing nothing but just defining columns of the output table:
 
 $SrvcName =@{label="Service Name" ;alignment="left" ;width=20 ;Expression={$_.Name};};
 $SrvcMode =@{label="Start Mode" ;alignment="left" ;width=20 ;Expression={$_.StartMode};};
 $SrvcState =@{label="State" ;alignment="left" ;width=20 ;Expression={$_.State};};
 $SrvcMsg =@{label="Message" ;alignment="left" ;width=30 ; `
 Expression={ if ($_.State -ne "Running") {"Alarm: Stopped"} else {"OK"} };};

 #Here is what I am doing the basic job, With the help of Get-WmiObject cmdlet I am getting the status information of 
 #SQL Server services and SQL Agent services. And with a simple for loop, I am getting start mode, state and status information.
 
 foreach($server in $servers)
 {
 
 $srvc = Get-WmiObject `
 -query "SELECT * 
 FROM win32_service 
 WHERE name LIKE '%MSSQL%' 
 OR name LIKE '%SQLAgent%'" `
 -computername $server `
 | Sort-Object -property name;
 
 Write-Output ("Server: {0}" -f $server);
 Write-Output $srvc | Format-Table $SrvcName, $SrvcMode, $SrvcState, $SrvcMsg; 
 }
 #Here is the last part of the code, the outer loop is for all servers, and the inner one is for all instances.
 
 foreach($server in $servers)
 {
 $insts= Get-SQLInstance -ComputerName $server
 
 
 foreach($inst in $insts)
 {
 
 #customizing the result of the function here
 
 $sqlinst =if ($inst -eq "MSSQLSERVER") {"$server"} else {"$server\$inst"};
 
 #T-SQL code checks the status of DBs, if all is ONLINE; then it returns OK; #if not it lists the offline DBs
 
 $q = "declare @offline table
 (instname varchar(20),
 dbname sysname,
 status varchar(20))
 
 declare @query varchar(max)
 declare @all int
 select @all = count(name) from sys.databases
 --select @all
 declare @online int
 select @online = count(name) from sys.databases where state=0
 --select @online
 if ( @online = @all)
 begin
 
 set @query='select @@servername as instname, ''all DBs'' as dbname, ''OK'' as status '
 insert into @offline
 exec (@query)
 
 
 select getdate() as datetime, * from @offline
 end
 else 
 begin
 
 
 set @query = 'select @@servername as instname, name as db_name, state_desc from sys.databases where state<>0'
 
 insert into @offline
 exec (@query)
 
 
 select getdate() as datetime, * from @offline
 end" 
 
 
 #Invoke-SQLcmd cmdlet is used to run a query on a SQL instance within #Powershell.
 Invoke-Sqlcmd -ServerInstance $sqlinst -Database "master" -Query $q `
 }  } 

You can save the above code as status.ps1 file under the path C:\control_scripts. Last step is running this code in a bat file called STATUS.bat:

The code for STATUS.bat file should be like below:

powershell.exe "C:\control_scripts\status.ps1" -noclobber >status.txt 2> status_error.txt

If the result is successful it will write it to status.txt file as shown below:

If it gets any error, it will write the details of the error(s) to status_error.txt file.

and creating data collector sets (https://technet.microsoft.com/en-us/library/cc722414.aspx). Another method is using Powershell script. Here you go with the script:

#In do-while loop, you can define how many times you would like to run the script with one execution. 
 #Get-Counter cmdlet has -max samples parameter as well, however if you set it a value other than 1 then
 #it waits until the end of the script to write the database after collecting all samples.
 #With the logic of do-while loop I managed to write the database after each sample collection.
 $a = 0 
 do
 {
 #$server variable defines the server to be monitored
 #if you would like to monitor more than 1 server you can use Get-Content cmdlet as shown below:
 #$server = @(get-content "C:\perfcounter_ps\AllServers.txt")
 $server = 'ISILEFE03'
 #$monitorServer variable defines the server that we are collecting data on and $monitorDB variable defines
 #the database that we are using like a datawarehouse
 $monitorServer = "ISILEFE03" 
 $monitorDB = "testperf" 
 $counters = @("\Memory\Available MBytes",
 "\Memory\Pages/sec",
 "\PhysicalDisk(_Total)\Avg. Disk sec/Read",
 "\PhysicalDisk(_Total)\Avg. Disk sec/Write",
 "\PhysicalDisk(_Total)\Current Disk Queue Length",
 "\PhysicalDisk(*)\Avg. Disk sec/Read",
 "\PhysicalDisk(*)\Avg. Disk sec/Write",
 "\PhysicalDisk(*)\Current Disk Queue Length",
 "\Process(sqlservr)\% Privileged Time",
 "\Process(sqlservr)\% Processor Time",
 "\Processor(_Total)\% Privileged Time",
 "\Processor(_Total)\% Processor Time",
 "\SQLServer:Buffer Manager\Buffer cache hit ratio",
 "\SQLServer:Buffer Manager\Lazy writes/sec",
 "\SQLServer:Buffer Manager\Page life expectancy",
 "\SQLSERVER:Memory Manager\Memory Grants Pending" ,
 "\SQLServer:SQL Statistics\Batch Requests/sec",
 "\System\Context Switches/sec",
 "\System\Processor Queue Length" 
 ) 
 $sequence=1 
 $collections = Get-Counter -ComputerName $server -Counter $counters -SampleInterval 10 -MaxSamples 1
 Write-Output $collections 
 foreach ($collection in $collections) 
 {$sampling = $collection.CounterSamples | Select-Object -Property TimeStamp, Path, Cookedvalue 
 $xmlString = $sampling | ConvertTo-Xml -As String
 #dbo.usp_InserPerfmonCounter is the stored procedure that is used to insert collected data to testperf database
 $query = "dbo.usp_InsertPerfmonCounter '$xmlString';" 
 Invoke-Sqlcmd -ServerInstance $monitorServer -Database $monitorDB -Query $query
 Write-Output $sampling
 $sequence+=1}
 #Write-Output $sampling 
 #Write-Output $xmlString 
 #Write-Output $query 
 $a+=1
 Write-Output $a
 }
 while($a-lt 10) 
 

The script for the stored procedure dbo.usp_InsertPerfmonCounter is: 

(refering https://www.travisgan.com/2013/03/powershell-and-performance-monitor.html)  

USE [testperf]
 GO
 
 /****** Object: StoredProcedure [dbo].[usp_InsertPerfmonCounter] Script Date: 11/5/2013 11:27:48 AM ******/
 SET ANSI_NULLS ON
 GO
 
 SET QUOTED_IDENTIFIER ON
 GO
 
 CREATE PROCEDURE [dbo].[usp_InsertPerfmonCounter]
 (
 @xmlString varchar(max)
 )
 AS
 SET NOCOUNT ON;
 
 DECLARE @xml xml;
 SET @xml = @xmlString;
 
 INSERT INTO [dbo].[PerfmonCounterData] ([TimeStamp], [Server], [CounterGroup], [CounterName], [CounterValue])
 SELECT [Timestamp]
 , SUBSTRING([Path], 3, CHARINDEX('\',[Path],3)-3) AS [Server]
 , SUBSTRING([Path]
 , CHARINDEX('\',[Path],3)+1
 , LEN([Path]) - CHARINDEX('\',REVERSE([Path]))+1 - (CHARINDEX('\',[Path],3)+1)) AS [CounterGroup]
 , REVERSE(LEFT(REVERSE([Path]), CHARINDEX('\', REVERSE([Path]))-1)) AS [CounterName]
 , CAST([CookedValue] AS float) AS [CookedValue]
 FROM
 (SELECT
 [property].value('(./text())[1]', 'VARCHAR(200)') AS [Value]
 , [property].value('@Name', 'VARCHAR(30)') AS [Attribute]
 , DENSE_RANK() OVER (ORDER BY [object]) AS [Sampling]
 FROM @xml.nodes('Objects/Object') AS mn ([object]) 
 CROSS APPLY mn.object.nodes('./Property') AS pn (property)) AS bp
 PIVOT (MAX(value) FOR Attribute IN ([Timestamp], [Path], [CookedValue]) ) AS ap;
 
GO

And here is the script of the table that I used.

CREATE TABLE [dbo].[PerfmonCounterData]
 (
 [ID] [bigint] IDENTITY(1,1) NOT NULL PRIMARY KEY CLUSTERED,
 [Server] [nvarchar](50) NOT NULL,
 [TimeStamp] [datetime2](0) NOT NULL,
 [CounterGroup] [varchar](200) NULL,
 [CounterName] [varchar](200) NOT NULL,
 [CounterValue] [decimal](18, 5) NULL
 );
 GO

And then when we run my script with the command below on Powershell, we can check the result from our table 

for inserted data.The result is written for every 10 sec as we expected since sampleinterval parameter is 10 sec 

for Get-Counter cmdlet. And with the help of do-while loop, the data is written 10 times with every execution of 

the script. It means that the execution of the script takes 100+ seconds.

cd "C:\perfcounter_ps"
powershell.exe .\collectperfdata.ps1

And here is our last step, scheduling a SQL Server agent job to run periodically, The only thing you 

should take into consideration is just changing the type as Powershell. After this point, you can just send 

queries filtering according to counter or timestamp, even you can visualize your data on Reporting Services. 

BE CAREFUL that i am using SQL Server 2012, and it is enough when I import sql powershell module 

once to be able to use SQL cmdlets like Invoke-SQLcmd. In fact, SQL Module is coming with sql 

server installation and the only thing you should do is running Import-Module -Name sqlps command. 

However, if you are using a lower version of SQL Server, since there is not a sql module you should be 

importing sql assemblies at the beginning of our powershell script. 

One of the features I like most with 2008 is Central Management Server. CMS introduces us with multi server management. However, it only shows the results in SSMS and does not save the result set.  To get the result set in a SQL Server table, the only thing you need is a handy Power Shell script. Let me explain this script with a simple example.

I have my default instance ISILEFE01 registered as a Central Management Server and two instances registered as members, named as ISILEFE01\ISIL and ISILEFE01\EFE.

Now, let’s run a very simple query to get the versions of all SQL server instances registered under CMS.

That’s all what CMS can do. Further we will go with Powershell. Please review the powershell script below:

$CentralManagementServer = "ISILEFE01"
$HistoryDatabase = "PSDatabase"

function ResultInsert($sqlServerVariable, $sqlDatabaseVariable, $EvaluatedServer, $EvaluatedResult)
{

 $sqlQueryText = "INSERT INTO dbo.test  (servername1,servername2) VALUES('$EvaluatedServer', '$EvaluatedResult')"
 write-output $sqlQueryText
 Invoke-Sqlcmd -ServerInstance $sqlServerVariable -Database $sqlDatabaseVariable -Query $sqlQueryText

}

$sconn = new-object System.Data.SqlClient.SqlConnection("server=$CentralManagementServer;Trusted_Connection=true");

$q = "select name from [msdb].[dbo].[sysmanagement_shared_registered_servers_internal];"

$sconn.Open()
$cmd = new-object System.Data.SqlClient.SqlCommand ($q, $sconn);
$cmd.CommandTimeout = 0;
$dr = $cmd.ExecuteReader();

while ($dr.Read()) {
 $ServerName = $dr.GetValue(0);
     
      $sqlQueryText = "select @@version"
     
      $selectResult=Invoke-Sqlcmd -ServerInstance $ServerName -Query $sqlQueryText
      [string]$a=$selectResult.column1

      ResultInsert $CentralManagementServer $HistoryDatabase $ServerName $a;
      
 }

$dr.Close()
$sconn.Close()

According to the script, I would like to get the results into a sql server table on my default instance, ISILEFE01. I created a database called “PSDatabase” and a table called “test” on my default instance, ISILEFE01.

The important point here is that the names of the SQL Server’s instances registered in CMS is written in a table called as “[msdb].[dbo].[sysmanagement_shared_registered_servers_internal]” . By running a select query to that table, I can retrieve the names of the sql server instances and then in a simple loop I can run any T-SQL query on all instances registered under CMS.

Lastly, in my main function I am calling a function to insert the values that I retrieve, to the “test” table under “PSDatabase”.  Now pls check what is inserted in the test table:

Enjoy managing your SQL servers with Powershell!