Export (0) Print
Expand All
Automate Testing of Your Stored Procs
Streamline Your Database Setup Process with a Custom Installer
Stop SQL Injection Attacks Before They Stop You
Get a Lean, Mean Dev Machine with the Express Editions of Visual Basic and SQL Server 2005
Keep Bad Guys at Bay with the Advanced Security Features in SQL Server 2005
AMO Lets You Dig Deeper into Your Data from Your Own Applications
Make Sense of Your Web Feedback using SQL Server 2005
Fuzzy Lookups and Groupings Provide Powerful Data Cleansing Capabilities
Unearth the New Data Mining Features of Analysis Services 2005
Using XQuery, New Large DataTypes, and More
Expand Minimize

Alerting on Database Mirroring Events

Published: April 7, 2006

Writer: Phillip Garding, Microsoft Corporation

Applies To: SQL Server 2005 Service Pack 1

Summary: Database mirroring in SQL Server 2005 helps ensure that your critical data is always available by maintaining a "hot" standby database. As with any distributed database technology, it is critical that you monitor the activity of the distributed system to ensure that synchronization is ongoing and to know when failovers occur. SQL Server 2005 provides tools that make event-monitoring easy. SQL Server 2005 generates events based on performance thresholds and on status changes in a mirroring session, and you can define alerts to notify you of these events. When you are notified of an event, you can use Database Mirroring Monitor to see the status of your mirroring session and troubleshoot any problems that occur.

This document describes the database mirroring events that SQL Server generates and how to configure alerts on these events using SQL Server Agent. Two sample scripts are also provided to demonstrate these concepts.

On This Page

Introduction
Performance Threshold Events
Database Mirroring State Change Events
Script Sample - Record Database Mirroring State Changes
Script Sample - Create Alerts for All Database Mirroring Events
Conclusion

Introduction

An important part of monitoring a mirrored database is configuring alerts on significant database mirroring events. SQL Server 2005 supports two types of events for database mirroring:

  • SQL Server message events based on user-defined performance thresholds that are logged to the Windows event log when the thresholds are exceeded

  • Windows Management Instrumentation (WMI) events that are generated when changes occur in the internal state of a database mirroring session

You can configure alerts using SQL Server Agent or other applications, such as Microsoft Operations Manager (MOM), to notify you when these events occur.

An important consideration when defining alerts on database mirroring events is to define performance thresholds and alerts at both partner server instances. Individual events are generated at either the principal or the mirror server, but each partner can perform either role at any given time. To ensure that an alert continues to operate after a failover, the alert must be defined at both server instances.

Performance Threshold Events

Starting with Service Pack 1, SQL Server 2005 allows you to enable events to be generated on four performance metrics. You define the threshold at which the event is generated. These events act as warnings when the performance does not meet your performance requirements as defined by the thresholds you have set.

Configuring Performance Thresholds

To configure performance thresholds in Database Mirroring Monitor, do the following:

  1. In SQL Server Management Studio, right-click a mirrored database.

  2. On the shortcut menu, point to Tasks, and then click Launch Database Mirroring Monitor.

  3. If you have not already done so, register the mirrored database for which you want to configure alerts in Database Mirroring Monitor.

  4. Select the database in the Navigation Pane.

  5. In the Detail Pane, click the Warnings tab. You can review the current settings for thresholds at both the principal and mirror server instance on this page.

  6. To change the settings, click Set Thresholds. Database Mirroring Monitor will display the Set Warning Thresholds dialog box as shown in Figure 1, where you can enable or disable warning events and specify threshold values.

Cc966392.29317_figure1(en-us,TechNet.10).jpg

Figure 1: Set Warning Thresholds dialog box.

You can also configure thresholds using system stored procedures. To enable a threshold and set the threshold value, call sys.sp_dbmmonitorchangealert. To disable a threshold, call sys.sp_dbmmonitordropalert. To get information about the current settings for a threshold, call sys.sp_dbmmonitorhelpalert. Note that these procedures configure the events that are used to alert you of performance problems; you must configure the alert notification using SQL Server Agent, Microsoft Operations Manager, or another program after configuring the threshold values. These stored procedures have a parameter named @alert_id, which specifies the threshold you want to configure. Possible values for @alert_id are listed in Table 1 later in this article. Note that you must be a member of the sysadmin fixed server role to execute these stored procedures.

Creating Alerts Based on Performance Threshold Events

After defining the performance thresholds, you can define alerts to notify you when the events occur.

Performance is evaluated against the thresholds by a system-stored procedure, sys.sp_dbmmonitorupdate. When this procedure is called, it evaluates performance and also inserts a row into the database mirroring status table in MSDB. You can call this stored procedure directly, or you can rely on a SQL Server Agent job, Database Mirroring Monitor Job, to do it on a regular schedule. This job is created automatically on a server instance when you use Management Studio to configure mirroring for at least one database on that instance. If you do not use Management Studio to configure mirroring, you can configure the job manually by calling another system stored procedure, sys.sp_dbmmonitoraddmonitoring. (Note that you must be a member of the sysadmin fixed server role to execute these system-stored procedures.) By default, the job is scheduled to run once per minute, which is the minimum schedule frequency allowed by SQL Server Agent. Thresholds will be evaluated and rows inserted into the status table more frequently if Database Mirroring Monitor is running. Every time Database Mirroring Monitor refreshes its display, sys.sp_dbmmonitorupdate is executed.

When sys.sp_dbmonitorupdate detects that a performance threshold is crossed, it raises a SQL Server error with a severity of 10, and SQL Server logs an Information event to the Windows event log. It is appropriate to designate the event as Information instead of Error, because the event is meant as a warning that the mirroring session performance has dropped below your defined threshold, but mirroring has not stopped altogether. In many cases, the performance degradation may be temporary. If the performance degradation is due to an unusual increase in data changes or to temporary network problems, the problem will likely fix itself over time.

The stored procedure can generate the events shown in Table 1.

Table 1: Event IDs for Performance Warnings

Warning

sp_dbmmonitorchangealert
@alert_id Parameter Value

Event ID / Error #

Warn if the age of the oldest unsent transaction exceeds the threshold

1

32040

Warn if the unsent log exceeds the threshold

2

32042

Warn if the unrestored log exceeds the threshold

3

32043

Warn if the mirror commit overhead exceeds the threshold

4

32044

In the event log, the source of these events is "MSSQL$<instance name>" for a named instance or "MSSQLSERVER" for the default instance.

You can define alerts on these events using SQL Server Agent or any application that monitors the event log, such as Microsoft Operations Manager. If the application that you use looks only for error events, however, it will miss these information events. You may need to customize the application to alert you when these warning events occur. For example, you can create a SQL Server Agent alert or a Microsoft Operations Manager rule that watches for the specific server error number or event ID.

Each time sys.sp_dbmmonitorupdate is executed, it compares the current performance to the thresholds and logs an event if the conditions warrant it. The stored procedure does not consider whether the same event has been logged recently. Consequently, if you have an ongoing performance problem you could see an event every minute or more. When defining alerts, you should use the alerting program to limit how often you are notified of the event. For example, SQL Server Agent allows you set a minimum time between notifications for the same event. This will prevent you from being notified more frequently than desired.

Figure 2 shows the dialog box you use to create a SQL Server Agent alert in Management Studio.

Cc966392.29317_figure2(en-us,TechNet.10).jpg

Figure 2: Alert Properties Dialog Box showing a SQL Server error-based alert.

To create an alert using SQL Server Agent, do the following:

  1. In Management Studio, connect to the principal or mirror server instance for which you want to define an alert.

  2. Expand the SQL Server Agent folder in Object Explorer.

  3. Right-click Alerts and select New Alert.

  4. In the New Alert dialog box, type a name you can use to identify the alert, such as "DB Mirroring: Unsent log warning."

  5. Specify a database name if you want the alert to occur only when the threshold is exceeded in a specific database. Select <all databases> to have the alert occur when the threshold is exceeded in any mirrored database on the server instance.

  6. Select Error number and type the number from Table 1.

  7. In Select a page, click Response to specify the actions to take when the event occurs, such as executing a job or notifying an operator.

  8. In Select a page, click Options to specify how often to send a notification on this event, the format of the message sent to operators, and other options.

You can also define SQL Server Agent alerts in Transact-SQL scripts using sp_add_alert. For example:

EXEC msdb.dbo.sp_add_alert 
	@name=N'DB Mirroring: Unsent Log Warning', 
	@category_name=N'Database Mirroring'
	@message_id=32042, 
	@severity=0, 
	@delay_between_responses=1800, 
	@include_event_description_in=0,
	@enabled=1

For sample scripts to create alerts, see Script Sample — Recording Database Mirroring State Changes and Script Sample — Creating Alerts for All Database Mirroring Events later in this document.

Database Mirroring State Change Events

Database Mirroring States

A database mirroring session is always in one of several states that indicate the current activity in the session and the status of the connections between the server instances. When conditions change, the internal state of the session changes. A session can be in any of the states shown in Table 2.

Table 2: Database Mirroring Session States

State

Name

Description

0

Null Notification

This state occurs briefly when a mirroring session is started.

1

Synchronized Principal with Witness

This state occurs on the principal when the principal and mirror are connected and synchronized and the principal and witness are connected. For a mirroring configuration with a witness, this is the normal operating state.

2

Synchronized Principal without Witness

This state occurs on the principal when the principal and mirror are connected and synchronized but the principal does not have a connection to the witness. For a mirroring configuration without a witness, this is the normal operating state.

3

Synchronized Mirror with Witness

This state occurs on the mirror when the principal and mirror are connected and synchronized and the mirror and witness are connected. For a mirroring configuration with a witness, this is the normal operating state.

4

Synchronized Mirror without Witness

This state occurs on the mirror when the principal and mirror are connected and synchronized but the mirror does not have a connection to the witness. For a mirroring configuration without a witness, this is the normal operating state.

5

Connection with Principal Lost

This state occurs on the mirror server instance when it cannot connect to the principal.

6

Connection with Mirror Lost

This state occurs on the principal server instance when it cannot connect to the mirror.

7

Manual Failover

This state occurs on the principal server instance when the user fails over manually from the principal, or on the mirror server instance when a force service is executed at the mirror.

8

Automatic Failover

This state occurs on the mirror server instance when the operating mode is high safety with automatic failover (synchronous) and the mirror and witness server instances cannot connect to the principal server instance.

9

Mirroring Suspended

This state occurs on both partner instances when the user suspends (pauses) the mirroring session or when the mirror server instance encounters an error. It also occurs on the mirror server instance following a force service command. When the mirror comes online as the principal, mirroring is automatically suspended.

10

No Quorum

If a witness is configured, this state occurs on the principal or mirror server instance when it cannot connect to its partner or to the witness server instance.

11

Synchronizing Mirror

This state occurs on the mirror server instance when there is a backlog of unsent log. The status of the session is Synchronizing.

12

Principal Running Exposed

This state occurs on the principal server instance when the operating mode is high protection (synchronous) and the principal cannot connect to the mirror server instance.

13

Synchronizing Principal

This state occurs on the principal server instance when there is a backlog of unsent log. The status of the session is Synchronizing.

The duration of many of these states is momentary, as the mirroring session responds to connection and other changes. For example, if a mirroring between two partners is operating in high safety mode with automatic failover, and you execute a manual failover, the mirroring session on the principal server instance goes through the following states:

  • Synchronized Principal with Witness (1)

  • Manual Failover (7)

  • Synchronizing Mirror (11)

  • Synchronized Mirror with Witness (3)

WMI Events Generated on Mirroring State Changes

When a mirroring session changes from one state to another, SQL Server generates a WMI event of type DATABASE_MIRRORING_STATE_CHANGE under the namespace \\.\root\Microsoft\SqlServer\ServerEvents\ <instance_name> , where <instance_name> is MSSQLSERVER for a default instance or the instance name for a named instance. The event includes the following properties:

Table 3: Properties of a Database Mirroring State Change WMI Event

Name

CIM Type

Description

StartTime

DateTime

The time that the event occurred. Note that the WMI DateTime type and the SQL Server datetime type are not compatible.

ComputerName

String

The server name

SQLInstance

String

The name of the instance in which the event occurred ("MSSQLSERVER" for the default instance).

DatabaseName

String

The name of the mirrored database

DatabaseID

Sint32

The ID of the mirrored database

State

Sint32

A number that represents the state—see Table 2 for details

TextData

String

Text that describes the old and new states, in the following format: <old state name> -> <new state name>

One of the most important properties is StartTime, which provides the time at which the state change occurred. Unfortunately, the WMI DateTime type is not compatible with the SQL Server datetime type. You cannot convert values between the two types using the CONVERT() function. The format of the WMI DateTime property is yyyymmddhhmmss.nnnnnnn. For example, the value 20060130163734.000323 represents the date January 30, 2006 and time 16:37 with 34.000323 seconds.

For a complete list of properties see the DATABASE_MIRRORING_STATE_CHANGE topic in SQL Server 2005 Books Online.

Creating Alerts Based on State Change Events

You can define alerts on these events using SQL Server Agent or any application that detects WMI events, such as Microsoft Operations Manager. Figure 3 shows the dialog box you use to create a SQL Server Agent alert in Management Studio.

Cc966392.29317_figure3(en-us,TechNet.10).jpg

Figure 3: Alert Properties Dialog Box showing a WMI-based alert.

To create an alert using SQL Server Agent, do the following:

  1. In Management Studio, connect to the principal or mirror server instance on which you want to define an alert.

  2. Expand the SQL Server Agent folder in Object Explorer.

  3. Right-click Alerts and click New Alert.

  4. In the New Alert dialog box, type the name of the alert.

  5. In the Type list, select WMI event alert. The dialog box then changes to show the relevant properties. The WMI namespace for the current server instance event is entered automatically.

  6. In the Query box, enter a query that selects the events on which you want to alert. See below for a discussion of how this query can be written.

  7. In Select a page, click Response to specify the actions to take when the event occurs, such as executing a job or notifying an operator.

  8. In Select a page, click Options to specify how often to send a notification on this event, the format of the message sent to operators, and other options.

Queries to select WMI events are written in WMI Query Language (WQL), which is very similar to Structured Query Language (SQL) with a few additions. As with a SQL query, the syntax follows the basic SELECT … FROM … WITH … structure. The following query will select all mirroring state change events:

SELECT * FROM DATABASE_MIRRORING_STATE_CHANGE

You can optionally append a WHERE clause using the WMI event property values to restrict this alert to certain conditions. For example, if you want to limit the alert occurrence to only Automatic Failover state changes in the AdventureWorks database, you can append the following clause:

WHERE State = 8 AND Database = 'AdventureWorks'

You can also define SQL Server Agent alerts in Transact-SQL scripts using sp_add_alert. For example:

EXEC msdb.dbo.sp_add_alert 
	@name=N'DB Mirroring: State Changes', 
	@category_name=N'Database Mirroring', 
	@wmi_namespace=
	N'\\.\root\Microsoft\SqlServer\ServerEvents\<instance name>', 
	@wmi_query=N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE',
	@enabled=1

One response to a WMI-based SQL Server Agent alert is to execute a job when the alert occurs. When defining the job steps, you can use special tokens that extract the properties of the WMI event. The token is in the format of $(WMI( <property_name> ), where <property_name> is the name of any property defined for the WMI event, including those in Table 3. You should not use the $(A-xxx) tokens; those are for use when the alert is based on a SQL Server error number, not a WMI event.

For example, a job step that executes a T-SQL script could include the following statement:

set @Msg = 'State of $(ESCAPE_SQUOTE(WMI(DatabaseName))) database changed to
 $(ESCAPE_SQUOTE(WMI(State)))  on $(ESCAPE_SQUOTE(WMI(StartTime)))'

Note: For the runtime token to work, you need to modify the registry by to setting HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\MSSQL.x\SQLServerAgent\AlertReplaceRuntimeTokens to 1.

When the job is executed, SQL Server Agent replaces the tokens with the values of the WMI event properties. For example, if this statement was executed in response to pausing database mirroring on AdventureWorks, @Msg could have a value of "State of AdventureWorks database changed to 9 on 20060130163734.000323."

Note that you must enable the use of tokens in SQL Server Agent jobs. To do so, do the following:

  1. Right-click the SQL Server Agent folder in Object Explorer and click Properties on the shortcut menu.

  2. In the SQL Server Agent Properties dialog box, in Select a page, click Alert System.

  3. At the bottom of the page, select the Replace tokens for all job responses to alerts check box.

  4. Restart the SQL Server Agent service.

If you use SQL Server Agent alerts, you should be aware of the limitations on how frequently SQL Server Agent evaluates WMI-based alerts. SQL Server Agent evaluates WMI-based alerts in fixed-size batches at fixed intervals. By default, alerts are evaluated in batches of five at an interval of thirty seconds. Alerts are processed in a round-robin fashion, so if you have ten WMI-based alerts, five will be evaluated on the first interval, and the next five will be evaluated thirty seconds later. If you have many WMI-based alerts, it may take several minutes to evaluate them all, which can lead to a long delay between when the event occurs and the alert notifies you.

SQL Server Agent does not provide a user interface for controlling the interval and batch size for WMI-based alerts, but you can change two values in the Windows registry to control this behavior. The registry values are:

  • EventWMIPeekInterval. This value controls the interval at which WMI-based alerts are evaluated.

  • EventWMILimit. This value controls the number of alerts evaluated at each interval.

Both values are located under the registry key for the instance of SQL Server on which the SQL Server Agent alerts are created. The registry key is HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\<Instance ID>\SQLServerAgent where <Instance ID> is MSSQL.1 for the first instance of SQL Server, MSSQL.2 for the second instance, and so on.

You can improve the responsiveness of WMI-based alerts by increasing the batch size, reducing the interval, or both. To change the interval and batch size, do the following:

  1. On the Start menu, click Run.

  2. In the Run dialog box, in the Open box, type Regedit. Click OK.

  3. In the Registry Editor, select the following registry key for the appropriate instance of SQL Server: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\<Instance ID>\SQLServerAgent where <Instance ID> is MSSQL.1 for the first instance of SQL Server, and so forth.

  4. To set the interval value, double-click EventWMIPeekInterval in the right pane of the Registry Editor. In the Edit DWORD Value dialog box, enter an interval value in seconds in the Value data box, and click OK. For example, to set the interval to ten seconds, type "10" in Value data and select Decimal as the base.

  5. To set the batch size, double-click EventWMILimit in the right pane of the Registry Editor. In the Edit DWORD Value dialog box, enter a batch size value in the Value data box, and click OK. For example, to have SQL Server Agent process ten WMI-based alerts every interval, type "10" in Value data and select Decimal as the base.

Script Sample - Record Database Mirroring State Changes

This script creates a table [msdb].[dbo]. [DB Mirroring State Changes], a SQL Server Agent job, [DB Mirroring: Record State Changes], and a SQL Server Agent alert, [DB Mirroring: State Changes]. The alert occurs when SQL Server generates a WMI event indicating that database mirroring has changed its internal operating state. The alert executes the job, which has two steps: 1) insert a row into the mirroring status table by calling sys.sp_dbmmonitorupdate, and 2) insert a row into the table capturing details from the database mirroring state change event. Note that the history row inserted by job step one contains information about database mirroring at the time the job runs. The row inserted by job step two contains information at the time that the WMI event was generated.

-- Create table to record mirroring state changes
-- Table: [msdb].[dbo].[DB Mirroring State Changes]

-- NOTE: This script assumes that you are creating the alert on
-- the mirror or principal server instance. If you want to offload
-- processing to another instance, you must change the @namespace 
-- variable at the end of the script.
USE [msdb];
GO
SET ANSI_NULLS ON;
GO
SET QUOTED_IDENTIFIER ON;
GO
SET ANSI_PADDING ON;
GO
CREATE TABLE [dbo].[DB Mirroring State Changes](
	[Event Time] [varchar](max) NOT NULL,
	[Event Description] [varchar](max) NOT NULL,
	[New State] [int] NOT NULL,
	[Database] [varchar](max) NOT NULL
) ON [PRIMARY];

GO
SET ANSI_PADDING OFF;
GO

-- Create job to execute when database mirroring event states change
-- The job does two things: 1)inserts a mirroring history 
-- row by calling sys.sp_dbmmonitorupdate and 2) records
-- information from the WMI event about the state change
-- Job: [DB Mirroring: Record State Changes]
BEGIN TRANSACTION
DECLARE @ReturnCode INT;
SELECT @ReturnCode = 0;

IF NOT EXISTS (SELECT name FROM msdb.dbo.syscategories 
   WHERE name=N'Database Mirroring' AND category_class=1)
BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @class=N'JOB', 
   @type=N'LOCAL', @name=N'Database Mirroring';
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;

END;

DECLARE @jobId BINARY(16);
EXEC @ReturnCode =  msdb.dbo.sp_add_job 
   @job_name=N'DB Mirroring: Record State Changes', 
   @enabled=1, 
   @description=
      N'Called by alert that responds to DBM state change events', 
   @category_name=N'Database Mirroring', 
   @job_id = @jobId OUTPUT;
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;

-- Job Step 1: [Insert History Row]
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, 
   @step_name=N'Insert History Row', 
   @step_id=1, 
   @subsystem=N'TSQL', 
   @command=N'EXEC sys.sp_dbmmonitorupdate', 
   @database_name=N'msdb', 
   @flags=0;
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;

-- Job Step 2: [Record State Changes]
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, 
   @step_name=N'Record State Changes', 
   @step_id=2, 
   @subsystem=N'TSQL', 
   @command=N'INSERT INTO dbo.[DB Mirroring State Changes] (
      [Event Time],
      [Event Description],
      [New State],
      [Database] )
   VALUES (
      $(WMI(StartTime)),
      ''$(WMI(TextData))'',
      $(WMI(State)),
      ''$(WMI(DatabaseName))'' )', 
   @database_name=N'msdb', 
   @flags=0;
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;
EXEC @ReturnCode = msdb.dbo.sp_update_job @job_id = @jobId, 
   @start_step_id = 1;
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;
EXEC @ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, 
   @server_name = N'(local)';
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback;
COMMIT TRANSACTION;
GOTO EndSave;
QuitWithRollback:
	IF (@@TRANCOUNT > 0) ROLLBACK TRANSACTION;
EndSave:

-- Create an alert on database mirroring state change events
-- Alert: Alert [DB Mirroring: State Changes]
IF NOT EXISTS (SELECT name FROM msdb.dbo.syscategories 
   WHERE name=N'Database Mirroring' AND category_class=2)
BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @class=N'ALERT', 
   @type=N'NONE', @name=N'Database Mirroring';
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO Quit_Alert;

END;

-- The namespace must include the instance name from which the 
-- WMI events will originate. For example, if the instance is 
-- the default instance, use 'MSSQLSERVER'. If the instance is 
-- SVR1\INSTANCE, use 'INSTANCE'
DECLARE @namespace NVARCHAR(200);
IF (SERVERPROPERTY('InstanceName') IS NOT null)
BEGIN
   SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\'
      + CONVERT(NCHAR(128), SERVERPROPERTY('InstanceName'));
END;
ELSE
BEGIN
   SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\MSSQLSERVER';
END;
EXEC msdb.dbo.sp_add_alert @name=N'DB Mirroring: State Changes', 
   @message_id=0, 
   @severity=0, 
   @enabled=1, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace,
   @wmi_query=N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE ', 
   @job_id=@jobId;

Quit_Alert:

Script Sample - Create Alerts for All Database Mirroring Events

The following sample creates disabled alerts for all database mirroring events from the specified database. At the top of the script, you must assign the name of your mirrored database to @dbName. If the database is on a named instance, you must assign the instance name to @instanceName. To use one of these alerts, you must enable it first.

USE [msdb];
GO

DECLARE @ReturnCode INT;
SELECT @ReturnCode = 0;

-- NOTE: You must replace <database name> with the name of the 
-- mirrored database on which you want to alert and uncomment the 
-- DECLARE statement

-- DECLARE @dbName NVARCHAR(128);
SELECT @dbName = N'<database name>';

-- NOTE: This script assumes that you are creating the alert on
-- the mirror or principal server instance. If you want to offload
-- processing to another instance, you must change the @namespace 
-- variable as follows: Enter the name of the instance from which 
-- the WMI events will originate. For example, if the instance is 
-- the default instance, use 'MSSQLSERVER'. If the instance is 
-- SVR1\INSTANCE, use 'INSTANCE'
DECLARE @instanceName NVARCHAR(128);
IF (SERVERPROPERTY('InstanceName') IS NOT null)
BEGIN
   SELECT @instanceName = CONVERT(NVARCHAR(128), 
      SERVERPROPERTY('InstanceName'));
END;
ELSE
BEGIN
   SELECT @instanceName = N'MSSQLSERVER';
END;

-- Create an alert on database mirroring state change events
-- Alert: Alert [DB Mirroring: State Changes]
IF NOT EXISTS (SELECT name FROM msdb.dbo.syscategories WHERE 
   name=N'Database Mirroring' AND category_class=2)
BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @class=N'ALERT', 
   @type=N'NONE', @name=N'Database Mirroring';
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO Quit_Alert;

END;

DECLARE @namespace NVARCHAR(200);
DECLARE @wquery NVARCHAR(200);
DECLARE @alertName NVARCHAR(200);

-- ***************
-- Create a set of alerts based on performance warnings
-- ***************

-- Create [DBM Perf: Unsent Log Threshold (<dbname>]
SELECT @alertName = N'DBM Perf: Unsent Log Threshold ('
      + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @category_name=N'Database Mirroring',
   @database_name = @dbName,
   @message_id=32042, 
   @severity=0, 
   @delay_between_responses=1800, 
   @include_event_description_in=0,
   @enabled=0;

-- Create [DBM Perf: Oldest Unsent Transaction Threshold (<dbname>]
SELECT @alertName = N'DBM Perf: Oldest Unsent Transaction Threshold ('
      + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @category_name=N'Database Mirroring',
   @database_name = @dbName,
   @message_id=32040, 
   @severity=0, 
   @delay_between_responses=1800, 
   @include_event_description_in=0,
   @enabled=0;

-- Create [DBM Perf: Unrestored Log Threshold (<dbname>]
SELECT @alertName = N'DBM Perf: Unrestored Log Threshold ('
      + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @category_name=N'Database Mirroring',
   @database_name = @dbName,
   @message_id=32043, 
   @severity=0, 
   @delay_between_responses=1800, 
   @include_event_description_in=0,
   @enabled=0;

-- Create [DBM Perf: Mirror Commit Overhead Threshold (<dbname>]
SELECT @alertName = N'DBM Perf: Mirror Commit Overhead Threshold ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @category_name=N'Database Mirroring',
   @database_name = @dbName,
   @message_id=32044, 
   @severity=0, 
   @delay_between_responses=1800, 
   @include_event_description_in=0,
   @enabled=0;

-- ***************
-- Create a set of alerts based on mirroring states
-- ***************

-- Create [DBM State: Synchronized Principal with Witness (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 1 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Synchronized Principal with Witness ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Synchronized Principal without Witness (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 2 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Synchronized Principal without Witness ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Synchronized Mirror with Witness (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 3 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Synchronized Mirror with Witness ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;;

-- Create [DBM State: Synchronized Mirror without Witness (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 4 AND DatabaseName = ''' + @dbName + ''''
SELECT @alertName = N'DBM State: Synchronized Mirror without Witness ('
   + @dbName + ')'
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Principal Connection Lost (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 5 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Principal Connection Lost ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Mirror Connection Lost (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 6 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Mirror Connection Lost ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Manual Failover (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 7 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Manual Failover ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Automatic Failover (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 8 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Automatic Failover ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Mirroring Suspended (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 9 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Mirroring Suspended ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: No Quorum (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 10 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: No Quorum ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Synchronizing Mirror (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 11 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Synchronizing Mirror ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Principal Running Exposed (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 12 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Principal Running Exposed ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

-- Create [DBM State: Synchronizing Principal (<dbname>)]
SELECT @namespace = N'\\.\root\Microsoft\SqlServer\ServerEvents\' 
   + @instanceName;
SELECT @wquery = N'SELECT * from DATABASE_MIRRORING_STATE_CHANGE 
   WHERE State = 13 AND DatabaseName = ''' + @dbName + '''';
SELECT @alertName = N'DBM State: Synchronizing Principal ('
   + @dbName + ')';
EXEC msdb.dbo.sp_add_alert 
   @name=@alertName, 
   @message_id=0, 
   @severity=0, 
   @enabled=0, 
   @delay_between_responses=0, 
   @include_event_description_in=0, 
   @category_name=N'Database Mirroring', 
   @wmi_namespace=@namespace, 
   @wmi_query=@wquery;

Quit_Alert:

Conclusion

For more information:
http://www.microsoft.com/technet/prodtechnol/sql/default.mspx

Download

DownloadAlerting on Database Mirroring Events
280 KB
Microsoft Word file

Show:
© 2014 Microsoft