select@@servername AS[server name], @@version AS [sql server and os version info];

-- Build                         Description            Release Date   

-- 13.0.200.172             CTP 2.0                 5/26/2015

-- 13.0.300.44               CTP 2.1                 6/14/2015

-- 13.0.407.1                 CTP 2.2                 7/28/2015

-- 13.0.500.53               CTP 2.3                 9/4/2015

-- 13.0.600.65               CTP 2.4                 9/30/2015

-- 13.0.700.242             CTP 3.0                 10/29/2015

-- 13.0.900.73               CTP 3.2                 12/12/2015

-- 13.0.1000.276           CTP 3.3                 1/27/2016

-- 13.0.1100.288            RC0                      3/2/2016

-- 13.0.1200.242            RC1                      3/18/2016

-- 13.0.1300.275            RC2                      3/28/2016

-- 13.0.1400.361            RC3                      4/11/2016

-- 13.0.1601.5                RTM                     6/1/2016 

EXEC sys.Xp_readerrorlog 

  0, 

  1, 

  N'detected', 

  N'socket'; 

SELECT Serverproperty('machinename')                AS[machinename], 

       Serverproperty('servername')                 AS[servername], 

       Serverproperty('instancename')               AS [instance], 

       Serverproperty('isclustered')                AS [isclustered], 

       Serverproperty('computernamephysicalnetbios')AS [computernamephysicalnetbios], 

       Serverproperty('edition')                    AS [edition], 

       Serverproperty('productlevel')               AS[productlevel], --what servicing branch (rtm/sp/cu) 

       Serverproperty('productupdatelevel')         AS[productupdatelevel], 

       -- within a servicing branch, what cu# is applied 

       Serverproperty('productversion')      AS[productversion], 

       Serverproperty('productmajorversion') AS[productmajorversion], 

       Serverproperty('productminorversion') AS [productminorversion], 

       Serverproperty('productbuild')        AS[productbuild], 

       Serverproperty('productbuildtype')    AS[productbuildtype], 

       -- is this a gdr or od hotfix (null if on a cu build) 

       Serverproperty('productupdatereference') AS [productupdatereference], 

       -- kb article number that is applicable for this build 

       Serverproperty('processid')                 AS [processid], 

       Serverproperty('collation')                 AS [collation], 

       Serverproperty('isfulltextinstalled')       AS[isfulltextinstalled], 

       Serverproperty('isintegratedsecurityonly')  AS[isintegratedsecurityonly], 

       Serverproperty('filestreamconfiguredlevel') AS[filestreamconfiguredlevel], 

       Serverproperty('ishadrenabled')             AS[ishadrenabled], 

       Serverproperty('hadrmanagerstatus')         AS[hadrmanagerstatus], 

       Serverproperty('isxtpsupported')            AS [isxtpsupported], 

       Serverproperty('instancedefaultdatapath')   AS[instancedefaultdatapath], 

       Serverproperty('instancedefaultlogpath')    AS[instancedefaultlogpath], 

       Serverproperty('ispolybaseinstalled')       AS[ispolybaseinstalled], 

       --new for sql server 2016 

       Serverproperty('isadvancedanalyticsinstalled')              AS [isrservicesinstalled],

       - new FOR sql server 2016 serverproperty('buildclrversion') AS [build clrversion];

SELECT NAME,       value,
       value_in_use,
       minimum,
       maximum,
       [description],
       is_dynamic,
       is_advanced
FROM   sys.configurations WITH (nolock)
ORDER  BY NAME
OPTION (recompile);  

DBCC tracestatus(-1); 

EXEC sys.Xp_readerrorlog 

  0, 
  1, 
  n'database instant file initialization';

SELECT physical_memory_in_use_kb / 1024 AS [sql server memory usage (mb)], 

       large_page_allocations_kb, 
       locked_page_allocations_kb, 
       page_fault_count, 
       memory_utilization_percentage, 
       available_commit_limit_kb, 
       process_physical_memory_low, 
       process_virtual_memory_low 
FROM   sys.dm_os_process_memory WITH (nolock) 
OPTION (recompile); 

SELECT servicename, 

       process_id, 
       startup_type_desc, 
       status_desc, 
       last_startup_time, 
       service_account, 
       is_clustered, 
       cluster_nodename, 
       [filename] 
FROM   sys.dm_server_services WITH (nolock) 
OPTION (recompile); 

SELECT sj.NAME                   AS [jobname], 

       sj.[description]          AS [jobdescription], 
       Suser_sname(sj.owner_sid) AS [jobowner], 
       sj.date_created, 
       sj.[enabled], 
       sj.notify_email_operator_id, 
       sj.notify_level_email, 
       sc.NAME                   AS [categoryname], 
       js.next_run_date, 
       js.next_run_time 
FROM   msdb.dbo.sysjobs AS sj WITH (nolock) 
       INNER JOIN msdb.dbo.syscategories AS sc WITH (nolock) 
               ON sj.category_id = sc.category_id 
       LEFT OUTER JOIN msdb.dbo.sysjobschedules AS js WITH (nolock) 
                    ON sj.job_id = js.job_id 
ORDER  BY sj.NAME 
OPTION (recompile); 

SELECT NAME, 

       event_source, 
       message_id, 
       severity, 
       [enabled], 
       has_notification, 
       delay_between_responses, 
       occurrence_count, 
       last_occurrence_date, 
       last_occurrence_time 
FROM   msdb.dbo.sysalerts WITH (nolock) 
ORDER  BY NAME 
OPTION (recompile); 

SELECT windows_release, 

       windows_service_pack_level, 
       windows_sku, 
       os_language_version 
FROM   sys.dm_os_windows_info WITH (nolock) 
OPTION (recompile); 

SELECT node_id, 

       node_state_desc, 
       memory_node_id, 
       processor_group, 
       online_scheduler_count, 
       active_worker_count, 
       avg_load_balance, 
       resource_monitor_state 
FROM   sys.dm_os_nodes WITH (nolock) 
WHERE  node_state_desc <> n'online dac' 
OPTION (recompile); 

SELECT total_physical_memory_kb / 1024     AS[Physical Memory (MB)], 

       available_physical_memory_kb / 1024 AS [Available Memory (MB)], 
       total_page_file_kb / 1024           AS [Total Page File (MB)], 
       available_page_file_kb / 1024       AS [Available Page File (MB)], 
       system_cache_kb / 1024              AS [System Cache (MB)], 
       system_memory_state_desc            AS [System Memory State] 
FROM   sys.dm_os_sys_memory WITH (nolock) 
OPTION (recompile); 

SELECT is_enabled, 

       [path], 
       max_size, 
       max_files 
FROM   sys.dm_os_server_diagnostics_log_configurations WITH (nolock) 
OPTION (recompile); 

SELECT nodename, 

       status_description, 
       is_current_owner 
FROM   sys.dm_os_cluster_nodes WITH (nolock) 
OPTION (recompile); 

SELECT cluster_name, 

       quorum_type_desc, 
       quorum_state_desc 
FROM   sys.dm_hadr_cluster WITH (nolock) 
OPTION (recompile);

SELECT cpu_count                     AS [logical cpu count], 

       scheduler_count, 
       hyperthread_ratio             AS [hyperthread ratio], 
       cpu_count / hyperthread_ratio AS [physical cpu count], 
       physical_memory_kb / 1024     AS [physical memory (MB)], 
       committed_kb / 1024           AS[committed memory (MB)], 
       committed_target_kb / 1024    AS [committed target memory (MB)], 
       max_workers_count             AS [max workers count], 
       affinity_type_desc            AS [affinity type], 
       sqlserver_start_time          AS [sql server start time], 
       virtual_machine_type_desc     AS[virtual machine type], 
       softnuma_configuration_desc   AS [soft numa configuration] 
FROM   sys.dm_os_sys_info WITH (nolock) 
OPTION (recompile); 

EXEC sys.Xp_readerrorlog 

  0, 
  1, 
  n'manufacturer'; 

EXEC sys.Xp_instance_regread 

  n'hkey_local_machine', 
  n'hardware\description\system\centralprocessor\0', 
  n'processornamestring'; 

SELECT [path], 

       state_description, 
       current_size_in_kb, 
       Cast (current_size_in_kb / 1048576.0 AS DECIMAL (10, 2)) AS [size (GB)] 
FROM   sys.dm_os_buffer_pool_extension_configuration WITH (nolock) 
OPTION (recompile); 

SELECT Db_name(database_id)                     AS [database name], 

       Count(page_id)                           AS [page count], 
       Cast(Count(*) / 128.0 AS DECIMAL(10, 2)) AS [buffer size(mb)], 
       Avg(read_microsec)                       AS 
       [avg read time (microseconds)] 
FROM   sys.dm_os_buffer_descriptors WITH (nolock) 
WHERE  database_id <> 32767 
       AND is_in_bpool_extension = 1 
GROUP  BY Db_name(database_id) 
ORDER  BY [buffer size(mb)] DESC 
OPTION (recompile); 

SELECT [filename], 

       creation_time, 
       size_in_bytes / 1048576.0 AS [size (mb)] 
FROM   sys.dm_server_memory_dumps WITH (nolock) 
ORDER  BY creation_time DESC 
OPTION (recompile); 

SELECT Db_name([database_id])          AS [database name], 

       [file_id], 
       NAME, 
       physical_name, 
       [type_desc], 
       state_desc, 
       is_percent_growth, 
       growth, 
       CONVERT(BIGINT, growth / 128.0) AS [growth in mb], 
       CONVERT(BIGINT, size / 128.0)   AS [total size in mb] 
FROM   sys.master_files WITH (nolock) 
ORDER  BY Db_name([database_id]) 
OPTION (recompile); 

SELECT DISTINCT vs.volume_mount_point, 

                vs.file_system_type, 
                vs.logical_volume_name, 
                CONVERT(DECIMAL(18, 2), vs.total_bytes / 1073741824.0) 
                AS [total size (gb)], 
                CONVERT(DECIMAL(18, 2), vs.available_bytes / 1073741824.0) 
                AS 
                [available size (gb)], 
                CONVERT(DECIMAL(18, 2), vs.available_bytes * 1. / vs.total_bytes 
                                        * 100.) AS 
                [space free %] 
FROM   sys.master_files AS f WITH (nolock) 
       CROSS apply sys.Dm_os_volume_stats(f.database_id, f.[file_id]) AS vs 
ORDER  BY vs.volume_mount_point 
OPTION (recompile); 

SELECT tab.[drive], 

       tab.volume_mount_point AS [volume mount point], 
       CASE 
         WHEN num_of_reads = 0 THEN 0 
         ELSE ( io_stall_read_ms / num_of_reads ) 
       END                    AS [read latency], 
       CASE 
         WHEN num_of_writes = 0 THEN 0 
         ELSE ( io_stall_write_ms / num_of_writes ) 
       END                    AS [write latency], 
       CASE 
         WHEN ( num_of_reads = 0 
                AND num_of_writes = 0 ) THEN 0 
         ELSE ( io_stall / ( num_of_reads + num_of_writes ) ) 
       END                    AS [overall latency], 
       CASE 
         WHEN num_of_reads = 0 THEN 0 
         ELSE ( num_of_bytes_read / num_of_reads ) 
       END                    AS [avg bytes/read], 
       CASE 
         WHEN num_of_writes = 0 THEN 0 
         ELSE ( num_of_bytes_written / num_of_writes ) 
       END                    AS [avg bytes/write], 
       CASE 
         WHEN ( num_of_reads = 0 
                AND num_of_writes = 0 ) THEN 0 
         ELSE ( ( num_of_bytes_read + num_of_bytes_written ) / 
                ( num_of_reads + num_of_writes ) ) 
       END                    AS [avg bytes/transfer] 
FROM   (SELECT LEFT(Upper(mf.physical_name), 2) AS drive, 
               Sum(num_of_reads)                AS num_of_reads, 
               Sum(io_stall_read_ms)            AS io_stall_read_ms, 
               Sum(num_of_writes)               AS num_of_writes, 
               Sum(io_stall_write_ms)           AS io_stall_write_ms, 
               Sum(num_of_bytes_read)           AS num_of_bytes_read, 
               Sum(num_of_bytes_written)        AS num_of_bytes_written, 
               Sum(io_stall)                    AS io_stall, 
               vs.volume_mount_point 
        FROM   sys.Dm_io_virtual_file_stats(NULL, NULL) AS vfs 
               INNER JOIN sys.master_files AS mf WITH (nolock) 
                       ON vfs.database_id = mf.database_id 
                          AND vfs.file_id = mf.file_id 
               CROSS apply sys.Dm_os_volume_stats(mf.database_id, mf.[file_id]) 
                           AS vs 
        GROUP  BY LEFT(Upper(mf.physical_name), 2), 
                  vs.volume_mount_point) AS tab 
ORDER  BY [overall latency] 
OPTION (recompile); 

SELECT Db_name(fs.database_id) 

       AS 
       [database name], 
       Cast(fs.io_stall_read_ms / ( 1.0 + fs.num_of_reads ) AS NUMERIC(10, 1)) 
       AS 
       [avg_read_stall_ms], 
       Cast(fs.io_stall_write_ms / ( 1.0 + fs.num_of_writes ) AS NUMERIC(10, 1)) 
       AS 
       [avg_write_stall_ms], 
       Cast(( fs.io_stall_read_ms + fs.io_stall_write_ms ) / ( 
                 1.0 + fs.num_of_reads + fs.num_of_writes ) AS NUMERIC(10, 1)) 
       AS 
       [avg_io_stall_ms], 
       CONVERT(DECIMAL(18, 2), mf.size / 128.0) 
       AS [file size (mb)], 
       mf.physical_name, 
       mf.type_desc, 
       fs.io_stall_read_ms, 
       fs.num_of_reads, 
       fs.io_stall_write_ms, 
       fs.num_of_writes, 
       fs.io_stall_read_ms + fs.io_stall_write_ms 
       AS [io_stalls], 
       fs.num_of_reads + fs.num_of_writes 
       AS [total_io], 
       io_stall_queued_read_ms 
       AS [resource governor total read io latency (ms)], 
       io_stall_queued_write_ms 
       AS [resource governor total write io latency (ms)] 
FROM   sys.Dm_io_virtual_file_stats(NULL, NULL) AS fs 
       INNER JOIN sys.master_files AS mf WITH (nolock) 
               ON fs.database_id = mf.database_id 
                  AND fs.[file_id] = mf.[file_id] 
ORDER  BY avg_io_stall_ms DESC 
OPTION (recompile); 

CREATE TABLE #iowarningresults 

  ( 
     logdate     DATETIME, 
     processinfo SYSNAME, 
     logtext     NVARCHAR(1000) 
  ); 

INSERT INTO #iowarningresults 
EXEC Xp_readerrorlog 
  0, 
  1, 
  n'taking longer than 15 seconds'; 

INSERT INTO #iowarningresults 
EXEC Xp_readerrorlog 
  1, 
  1, 
  n'taking longer than 15 seconds'; 

INSERT INTO #iowarningresults 
EXEC Xp_readerrorlog 
  2, 
  1, 
  n'taking longer than 15 seconds'; 

INSERT INTO #iowarningresults 
EXEC Xp_readerrorlog 
  3, 
  1, 
  n'taking longer than 15 seconds'; 

INSERT INTO #iowarningresults 
EXEC Xp_readerrorlog 
  4, 
  1, 
  n'taking longer than 15 seconds'; 

SELECT logdate, 
       processinfo, 
       logtext 
FROM   #iowarningresults 
ORDER  BY logdate DESC; 

DROP TABLE #iowarningresults;

SELECT db.[name]                                       AS [database name], 

       db.recovery_model_desc                          AS [recovery model], 
       db.state_desc, 
       db.containment_desc, 
       db.log_reuse_wait_desc                          AS 
       [log reuse wait description], 
       CONVERT(DECIMAL(18, 2), ls.cntr_value / 1024.0) AS [log size (mb)], 
       CONVERT(DECIMAL(18, 2), lu.cntr_value / 1024.0) AS [log used (mb)], 
       Cast(Cast(lu.cntr_value AS FLOAT) / Cast(ls.cntr_value AS FLOAT)AS 
            DECIMAL(18, 2)) * 100                      AS [log used %], 
       db.[compatibility_level]                        AS 
       [db compatibility level], 
       db.is_mixed_page_allocation_on, 
       db.page_verify_option_desc                      AS [page verify option], 
       db.is_auto_create_stats_on, 
       db.is_auto_update_stats_on, 
       db.is_auto_update_stats_async_on, 
       db.is_parameterization_forced, 
       db.snapshot_isolation_state_desc, 
       db.is_read_committed_snapshot_on, 
       db.is_auto_close_on, 
       db.is_auto_shrink_on, 
       db.target_recovery_time_in_seconds, 
       db.is_cdc_enabled, 
       db.is_published, 
       db.is_distributor, 
       db.is_encrypted, 
       db.group_database_id, 
       db.replica_id, 
       db.is_memory_optimized_elevate_to_snapshot_on, 
       db.delayed_durability_desc, 
       db.is_auto_create_stats_incremental_on, 
       db.is_query_store_on, 
       db.is_sync_with_backup, 
       db.is_supplemental_logging_enabled, 
       db.is_remote_data_archive_enabled, 
       db.is_encrypted, 
       de.encryption_state, 
       de.percent_complete, 
       de.key_algorithm, 
       de.key_length 
FROM   sys.databases AS db WITH (nolock) 
       INNER JOIN sys.dm_os_performance_counters AS lu WITH (nolock) 
               ON db.NAME = lu.instance_name 
       INNER JOIN sys.dm_os_performance_counters AS ls WITH (nolock) 
               ON db.NAME = ls.instance_name 
       LEFT OUTER JOIN sys.dm_database_encryption_keys AS de WITH (nolock) 
                    ON db.database_id = de.database_id 
WHERE  lu.counter_name LIKE n'log file(s) used size (kb)%' 
       AND ls.counter_name LIKE n'log file(s) size (kb)%' 
       AND ls.cntr_value > 0 
OPTION (recompile); 

SELECT CONVERT(DECIMAL(18, 2), user_seeks * avg_total_user_cost * ( 

                                      avg_user_impact * 0.01 )) AS 
       [index_advantage], 
       migs.last_user_seek, 
       mid.[statement]                                          AS 
       [database.schema.table], 
       mid.equality_columns, 
       mid.inequality_columns, 
       mid.included_columns, 
       migs.unique_compiles, 
       migs.user_seeks, 
       migs.avg_total_user_cost, 
       migs.avg_user_impact 
FROM   sys.dm_db_missing_index_group_stats AS migs WITH (nolock) 
       INNER JOIN sys.dm_db_missing_index_groups AS mig WITH (nolock) 
               ON migs.group_handle = mig.index_group_handle 
       INNER JOIN sys.dm_db_missing_index_details AS mid WITH (nolock) 
               ON mig.index_handle = mid.index_handle 
ORDER  BY index_advantage DESC 
OPTION (recompile); 

CREATE TABLE #vlfinfo 

  ( 
     recoveryunitid INT, 
     fileid         INT, 
     filesize       BIGINT, 
     startoffset    BIGINT, 
     fseqno         BIGINT, 
     [status]       BIGINT, 
     parity         BIGINT, 
     createlsn      NUMERIC(38) 
  ); 

CREATE TABLE #vlfcountresults 
  ( 
     databasename SYSNAME, 
     vlfcount     INT 
  ); 

EXEC Sp_msforeachdb 
n'use [?]; insert into #vlfinfo exec sp_executesql n''dbcc loginfo([?])'';                                                              insert into #vlfcountresults                                                              select db_name(), count(*) from #vlfinfo;                                                               truncate table #vlfinfo;' 

SELECT databasename, 
       vlfcount 
FROM   #vlfcountresults 
ORDER  BY vlfcount DESC; 

DROP TABLE #vlfinfo; 
DROP TABLE #vlfcountresults; 

WITH db_cpu_stats 
     AS (SELECT pa.databaseid, 
                Db_name(pa.databaseid)           AS [database name], 
                Sum(qs.total_worker_time / 1000) AS [cpu_time_ms] 
         FROM   sys.dm_exec_query_stats AS qs WITH (nolock) 
                CROSS apply (SELECT CONVERT(INT, value) AS [databaseid] 
                             FROM   sys.Dm_exec_plan_attributes(qs.plan_handle) 
                             WHERE  attribute = n'dbid') AS pa 
         GROUP  BY databaseid) 
SELECT Row_number() 
         OVER( 
           ORDER BY [cpu_time_ms] DESC)                              AS 
       [cpu rank], 
       [database name], 
       [cpu_time_ms]                                                 AS 
       [cpu time (ms)], 
       Cast([cpu_time_ms] * 1.0 / Sum([cpu_time_ms]) 
                                    OVER() * 100.0 AS DECIMAL(5, 2)) AS 
       [cpu percent] 
FROM   db_cpu_stats 
WHERE  databaseid <> 32767 -- resourcedb 
ORDER  BY [cpu rank] 
OPTION (recompile); 

Helps determine which database is using the most CPU resources on the instance.

WITH aggregate_io_statistics 

     AS (SELECT Db_name(database_id) AS [database name], 
                Cast(Sum(num_of_bytes_read + num_of_bytes_written) / 1048576 AS 
                     DECIMAL( 
                     12, 2)) 
                                     AS io_in_mb 
         FROM   sys.Dm_io_virtual_file_stats(NULL, NULL) AS [dm_io_stats] 
         GROUP  BY database_id) 
SELECT Row_number() 
         OVER( 
           ORDER BY io_in_mb DESC)                        AS [i/o rank], 
       [database name], 
       io_in_mb                                           AS [total i/o (mb)], 
       Cast(io_in_mb / Sum(io_in_mb) 
                         OVER() * 100.0 AS DECIMAL(5, 2)) AS [i/o percent] 
FROM   aggregate_io_statistics 
ORDER  BY [i/o rank] 
OPTION (recompile); 

WITH aggregatebufferpoolusage 

     AS (SELECT Db_name(database_id)                           AS 
                [database name], 
                Cast(Count(*) * 8 / 1024.0 AS DECIMAL (10, 2)) AS [cachedsize] 
         FROM   sys.dm_os_buffer_descriptors WITH (nolock) 
         WHERE  database_id <> 32767 -- resourcedb 
         GROUP  BY Db_name(database_id)) 
SELECT Row_number() 
         OVER( 
           ORDER BY cachedsize DESC)                        AS 
       [buffer pool rank], 
       [database name], 
       cachedsize                                           AS 
       [cached size (mb)], 
       Cast(cachedsize / Sum(cachedsize) 
                           OVER() * 100.0 AS DECIMAL(5, 2)) AS 
       [buffer pool percent] 
FROM   aggregatebufferpoolusage 
ORDER  BY [buffer pool rank] 
OPTION (recompile); 

DBCC sqlperf('sys.dm_os_wait_stats', clear); 

WITH [waits] 

     AS (SELECT wait_type, 
                wait_time_ms / 1000.0                           AS [waits], 
                ( wait_time_ms - signal_wait_time_ms ) / 1000.0 AS [resources], 
                signal_wait_time_ms / 1000.0                    AS [signals], 
                waiting_tasks_count                             AS [waitcount], 
                100.0 * wait_time_ms / Sum (wait_time_ms) 
                                         OVER()                 AS [percentage], 
                Row_number() 
                  OVER( 
                    ORDER BY wait_time_ms DESC)                 AS [rownum] 
         FROM   sys.dm_os_wait_stats WITH (nolock) 
         WHERE  [wait_type] NOT IN ( 
                n'broker_eventhandler', n'broker_receive_waitfor', 
                n'broker_task_stop', 
                n'broker_to_flush', 
                                     n'broker_transmitter', n'checkpoint_queue', 
                n'chkpt', 
                                           n'clr_auto_event', 
                                     n'clr_manual_event', n'clr_semaphore', 
                                           n'dbmirror_dbm_event', 
                n'dbmirror_events_queue' 
                , 
                                     n'dbmirror_worker_queue', 
                n'dbmirroring_cmd', 
                                           n'dirty_page_poll', 
                n'dispatcher_queue_semaphore', 
                                     n'execsync', n'fsagent', 
                n'ft_ifts_scheduler_idle_wait', 
                                           n'ft_iftshc_mutex', 
                                     n'hadr_clusapi_call', 
                n'hadr_filestream_iomgr_iocompletion' 
                                           , 
                n'hadr_logcapture_wait', 
                n'hadr_notification_dequeue', 
                                     n'hadr_timer_task', n'hadr_work_queue', 
                n'ksource_wakeup', 
                                           n'lazywriter_sleep' 
                                                                , 
                                     n'logmgr_queue', n'memory_allocation_ext', 
                                           n'ondemand_task_queue', 
                n'preemptive_os_libraryops', 
                                     n'preemptive_os_comops', 
                n'preemptive_os_cryptops', 
                                           n'preemptive_os_pipeops', 
                                           n'preemptive_os_authenticationops', 
                                     n'preemptive_os_genericops', 
                n'preemptive_os_verifytrust', 
                n'preemptive_os_fileops' 
                , 
                n'preemptive_os_deviceops', 
                                     n'pwait_all_components_initialized', 
                                           n'qds_persist_task_main_loop_sleep', 
                n'qds_async_queue', 
                n'qds_cleanup_stale_queries_task_main_loop_sleep' 
                , 
                                     n'request_for_deadlock_search', 
                n'resource_queue', 
                                           n'server_idle_check', 
                                           n'sleep_bpool_flush', 
                                     n'sleep_dbstartup', n'sleep_dcomstartup', 
                                           n'sleep_masterdbready', 
                                           n'sleep_mastermdready', 
                                     n'sleep_masterupgraded', 
                n'sleep_msdbstartup', 
                                           n'sleep_systemtask', 
                                           n'sleep_task', 
                                     n'sleep_tempdbstartup', n'sni_http_accept', 
                                           n'sp_server_diagnostics_sleep', 
                                           n'sqltrace_buffer_flush', 
                                     n'sqltrace_incremental_flush_sleep', 
                                           n'sqltrace_wait_entries', 
                                           n'wait_for_results', n'waitfor', 
                                     n'waitfor_taskshutdown', 
                n'wait_xtp_host_wait', 
                                           n'wait_xtp_offline_ckpt_new_log', 
                                           n'wait_xtp_ckpt_close', 
                                     n'xe_dispatcher_join', 
                n'xe_dispatcher_wait', 
                                           n'xe_live_target_tvf', 
                                           n'xe_timer_event' ) 
                AND waiting_tasks_count > 0) 
SELECT Max (w1.wait_type)                                                    AS 
       [waittype], 
       Cast (Max (w1.waits) AS DECIMAL (16, 2))                              AS 
       [wait_sec], 
       Cast (Max (w1.resources) AS DECIMAL (16, 2))                          AS 
       [resource_sec], 
       Cast (Max (w1.signals) AS DECIMAL (16, 2))                            AS 
       [signal_sec], 
       Max (w1.waitcount)                                                    AS 
       [wait count], 
       Cast (Max (w1.percentage) AS DECIMAL (5, 2))                          AS 
       [wait percentage], 
       Cast (( Max (w1.waits) / Max (w1.waitcount) ) AS DECIMAL (16, 4))     AS 
       [avgwait_sec], 
       Cast (( Max (w1.resources) / Max (w1.waitcount) ) AS DECIMAL (16, 4)) AS 
       [avgres_sec], 
       Cast (( Max (w1.signals) / Max (w1.waitcount) ) AS DECIMAL (16, 4))   AS 
       [avgsig_sec] 
FROM   waits AS w1inner 
       JOIN waits AS w2 
         ON w2.rownum <= w1.rownum 
GROUP  BY w1.rownum 
HAVING Sum (w2.percentage) - Max (w1.percentage) < 99 -- percentage threshold 
OPTION (recompile); 

SELECT ec.client_net_address, 

       es.[program_name], 
       es.[host_name], 
       es.login_name, 
       Count(ec.session_id) AS [connection count] 
FROM   sys.dm_exec_sessions AS es WITH (nolock) 
       INNER JOIN sys.dm_exec_connections AS ec WITH (nolock) 
               ON es.session_id = ec.session_id 
GROUP  BY ec.client_net_address, 
          es.[program_name], 
          es.[host_name], 
          es.login_name 
ORDER  BY ec.client_net_address, 
          es.[program_name] 
OPTION (recompile); 

SELECT Avg(current_tasks_count)   AS [avg task count], 

       Avg(work_queue_count)      AS [avg work queue count], 
       Avg(runnable_tasks_count)  AS [avg runnable task count], 
       Avg(pending_disk_io_count) AS [avg pending diskio count] 
FROM   sys.dm_os_schedulers WITH (nolock) 
WHERE  scheduler_id < 255 
OPTION (recompile); 

SELECT t1.resource_type                              AS [lock type], 

       Db_name(resource_database_id)                 AS [database], 
       t1.resource_associated_entity_id              AS [blk object], 
       t1.request_mode                               AS [lock req], 
       --- lock requested 
       t1.request_session_id                         AS [waiter sid], 
       t2.wait_duration_ms                           AS [wait time], 
       -- spid of waiter  
       (SELECT [text] 
        FROM   sys.dm_exec_requests AS r WITH (nolock) -- get sql for waiter 
               CROSS apply sys.Dm_exec_sql_text(r.[sql_handle]) 
        WHERE  r.session_id = t1.request_session_id) AS [waiter_batch], 
       (SELECT Substring(qt.[text], r.statement_start_offset / 2, ( CASE 
                                                                      WHEN 
               r.statement_end_offset = -1 THEN Len( 
               CONVERT(NVARCHAR(max), qt.[text])) 
                                                * 
                                                2 
                                                                      ELSE 
               r.statement_end_offset 
                                                                    END - 
               r.statement_start_offset ) / 2) 
        FROM   sys.dm_exec_requests AS r WITH (nolock) 
               CROSS apply sys.Dm_exec_sql_text(r.[sql_handle]) AS qt 
        WHERE  r.session_id = t1.request_session_id) AS [waiter_stmt], 
       -- statement blocked 
       t2.blocking_session_id                        AS [blocker sid], 
       (SELECT [text] 
        FROM   sys.sysprocesses AS p-- get sql for blocker 
               CROSS apply sys.Dm_exec_sql_text(p.[sql_handle]) 
        WHERE  p.spid = t2.blocking_session_id)      AS [blocker_batch] 
FROM   sys.dm_tran_locks AS t1 WITH (nolock) 
       INNER JOIN sys.dm_os_waiting_tasks AS t2 WITH (nolock) 
               ON t1.lock_owner_address = t2.resource_address 
OPTION (recompile); 

DECLARE @ts_now BIGINT = (SELECT cpu_ticks / ( cpu_ticks / ms_ticks ) 

   FROM   sys.dm_os_sys_info WITH (nolock)); 

SELECT TOP(256) sqlprocessutilization                                  AS 
                [sql server process cpu utilization], 
                systemidle                                             AS 
                [system idle process], 
                100 - systemidle - sqlprocessutilization               AS 
                [other process cpu utilization], 
                Dateadd(ms, -1 * ( @ts_now - [timestamp] ), Getdate()) AS 
                [event time] 
FROM   (SELECT record.value('(./record/@id)[1]', 'int') 
                      AS record_id, 
record.value('(./record/schedulermonitorevent/systemhealth/systemidle)[1]', 'int')         AS
[systemidle], 
record.value('(./record/schedulermonitorevent/systemhealth/processutilization)[1]', 'int') AS [sqlprocessutilization], 
[timestamp] 
 FROM   (SELECT [timestamp], 
                CONVERT(XML, record) AS [record] 
         FROM   sys.dm_os_ring_buffers WITH (nolock) 
         WHERE  ring_buffer_type = n'ring_buffer_scheduler_monitor' 
                AND record LIKE n'%<systemhealth>%') AS x) AS y 
ORDER  BY record_id DESC 
OPTION (recompile); 

SELECT TOP(50) 
            Db_name(t.[dbid])                         AS [databasename], 
            LEFT(t.[text], 50)                        AS [short query text], 
            qs.total_worker_time                      AS [total worker time], 
            qs.min_worker_time                        AS [min worker time], 
            qs.total_worker_time/qs.execution_count   AS [avgworker time], 
            qs.max_worker_time                        AS [max worker time], 
            qs.min_elapsed_time                       AS [min elapsed time], 
            qs.total_elapsed_time/qs.execution_count  AS [avg elapsed time], 
            qs.max_elapsed_time                       AS [max elapsed time], 
            qs.min_logical_reads                      AS [min logical reads], 
            qs.total_logical_reads/qs.execution_count AS [avg logical reads], 
            qs.max_logical_reads                      AS [max logical reads], 
            qs.execution_count                        AS [execution count], 
            qs.creation_time                          AS [creation time] 
            -- ,t.[text] as [query text], qp.query_plan as 
            [query plan] -- uncomment out these columns if not copying results to excel 
FROM        sys.dm_exec_query_stats             AS qs WITH (nolock) 
CROSS apply sys.dm_exec_sql_text(plan_handle)   AS t 
CROSS apply sys.dm_exec_query_plan(plan_handle) AS qp 
ORDER BY    qs.total_worker_time DESC OPTION(recompile);

SELECT @@servername AS [server name], 

       [object_name], 
       instance_name, 
       cntr_value   AS [page life expectancy] 
FROM   sys.dm_os_performance_counters WITH (nolock) 
WHERE  [object_name] LIKE n'%buffer node%' -- handles named instances 
       AND counter_name = n'page life expectancy' 
OPTION (recompile); 

SELECT @@servername AS [server name], 

       [object_name], 
       cntr_value   AS [memory grants pending] 
FROM   sys.dm_os_performance_counters WITH (nolock) 
WHERE  [object_name] LIKE n'%memory manager%' -- handles named instances 
       AND counter_name = n'memory grants pending' 
OPTION (recompile);

SELECT TOP(10) mc.[type]                                              AS 

               [memory clerk type], 
               Cast(( Sum(mc.pages_kb) / 1024.0 ) AS DECIMAL (15, 2)) AS 
               [memory usage (mb)] 
FROM   sys.dm_os_memory_clerks AS mc WITH (nolock) 
GROUP  BY mc.[type] 
ORDER  BY Sum(mc.pages_kb) DESC 
OPTION (recompile); 

SELECT TOP(50) [text]                  AS [querytext], 

               cp.cacheobjtype, 
               cp.objtype, 
               cp.size_in_bytes / 1024 AS [plan size in kb] 
FROM   sys.dm_exec_cached_plans AS cp WITH (nolock) 
       CROSS apply sys.Dm_exec_sql_text(plan_handle) 
WHERE  cp.cacheobjtype = n'compiled plan' 
       AND cp.objtype IN ( n'adhoc', n'prepared' ) 
       AND cp.usecounts = 1 
ORDER  BY cp.size_in_bytes DESC 
OPTION (recompile);