Étape 1: Créez un service pour recevoir les notifications et une file d'attente pour celui-ci:
use msdb;
go
create queue dbm_notifications_queue;
create service dbm_notification_service
on queue dbm_notifications_queue
([http://schemas.microsoft.com/SQL/Notifications/PostEventNotification]);
go
create event notification dbm_notifications
on server
for database_mirroring_state_change
to service N'dbm_notification_service', N'current database';
go
Notez que j'utilise msdb, ce n'est pas un accident. Étant donné que les notifications d'événements au niveau du serveur sont envoyées depuis, msdbil est préférable que vous créiez également le point de terminaison de conversation opposé (la cible) msdb, ce qui implique que le service de destination et la file d'attente doivent également être déployés dans msdb.
Étape 2: créez la procédure de traitement des notifications d'événements:
use msdb;
go
create table dbm_notifications_errors (
incident_time datetime not null,
session_id int not null,
has_rolled_back bit not null,
[error_number] int not null,
[error_message] nvarchar(4000) not null,
[message_body] varbinary(max));
create clustered index cdx_dbm_notifications_errors
on dbm_notifications_errors (incident_time);
go
create table mirroring_alerts (
alert_time datetime not null,
start_time datetime not null,
processing_time datetime not null,
database_id smallint not null,
database_name sysname not null,
[state] tinyint not null,
[text_data] nvarchar(max),
event_data xml not null);
create clustered index cdx_mirroring_alerts
on mirroring_alerts (alert_time);
go
create procedure dbm_notifications_procedure
as
begin
declare @dh uniqueidentifier, @mt sysname, @raw_body varbinary(max), @xml_body xml;
begin transaction;
begin try;
receive top(1)
@dh = conversation_handle,
@mt = message_type_name,
@raw_body = message_body
from dbm_notifications_queue;
if N'http://schemas.microsoft.com/SQL/Notifications/EventNotification' = @mt
begin
set @xml_body = cast(@raw_body as xml);
-- shred the XML and process it accordingly
-- IMPORTANT! IMPORTANT!
-- DO NOT LOOK AT sys.database_mirroring
-- The view represents the **CURRENT** state
-- This message reffers to an **EVENT** that had occured
-- the current state may or may no be relevant for this **PAST** event
declare @alert_time datetime
, @start_time datetime
, @processing_time datetime = getutcdate()
, @database_id smallint
, @database_name sysname
, @state tinyint
, @text_data nvarchar(max);
set @alert_time = @xml_body.value (N'(//EVENT_INSTANCE/PostTime)[1]', 'DATETIME');
set @start_time = @xml_body.value (N'(//EVENT_INSTANCE/StartTime)[1]', 'DATETIME');
set @database_id = @xml_body.value (N'(//EVENT_INSTANCE/DatabaseID)[1]', 'SMALLINT');
set @database_name = @xml_body.value (N'(//EVENT_INSTANCE/DatabaseName)[1]', 'SYSNAME');
set @state = @xml_body.value (N'(//EVENT_INSTANCE/State)[1]', 'TINYINT');
set @text_data = @xml_body.value (N'(//EVENT_INSTANCE/TextData)[1]', 'NVARCHAR(MAX)');
insert into mirroring_alerts (
alert_time,
start_time,
processing_time,
database_id,
database_name,
[state],
text_data,
event_data)
values (
@alert_time,
@start_time,
@processing_time,
@database_id,
@database_name,
@state,
@text_data,
@xml_body);
end
else if N'http://schemas.microsoft.com/SQL/ServiceBroker/Error' = @mt
begin
set @xml_body = cast(@raw_body as xml);
DECLARE @error INT
, @description NVARCHAR(4000);
WITH XMLNAMESPACES ('http://schemas.microsoft.com/SQL/ServiceBroker/Error' AS ssb)
SELECT @error = CAST(@xml_body AS XML).value('(//ssb:Error/ssb:Code)[1]', 'INT'),
@description = CAST(@xml_body AS XML).value('(//ssb:Error/ssb:Description)[1]', 'NVARCHAR(4000)');
insert into dbm_notifications_errors(
incident_time,
session_id,
has_rolled_back,
[error_number],
[error_message],
[message_body])
values (
getutcdate(),
@@spid,
0,
@error,
@description,
@raw_body);
end conversation @dh;
end
else if N'http://schemas.microsoft.com/SQL/ServiceBroker/EndDialog' = @mt
begin
end conversation @dh;
end
commit;
end try
begin catch
declare @xact_state int = xact_state(),
@error_number int = error_number(),
@error_message nvarchar(4000) = error_message(),
@has_rolled_back bit = 0;
if @xact_state = -1
begin
-- Doomed transaction, it must rollback
rollback;
set @has_rolled_back = 1;
end
else if @xact_state = 0
begin
-- transaction was already rolled back (deadlock?)
set @has_rolled_back = 1;
end
insert into dbm_notifications_errors(
incident_time,
session_id,
has_rolled_back,
[error_number],
[error_message],
[message_body])
values (
getutcdate(),
@@spid,
@has_rolled_back,
@error_number,
@error_message,
@raw_body);
if (@has_rolled_back = 0)
begin
commit;
end
end catch
end
go
L'écriture d'une procédure de courtier de services n'est pas votre code ordinaire. Il faut suivre certaines normes et il est très facile de s'éloigner en territoire sablonneux. Ce code montre quelques bonnes pratiques:
- encapsuler la file d'attente de messages et le traitement dans une transaction. Aucune évidence, évident.
- vérifiez toujours le type de message reçu. Une bonne procédure de courtier de services doit gérer
Erroret EndDialogenvoyer les messages de manière appropriée en fermant la boîte de dialogue de son côté. Ne pas le faire entraîne des fuites de poignée (se sys.conversation_endpointsdéveloppe)
- vérifiez toujours si un message a été retiré de la file d'attente par RECEIVE. Certains échantillons vérifient @@ rowcount après
RECEIVE, ce qui est parfaitement OK. Cet exemple de code repose sur la vérification du nom du message (aucun message n'implique un nom de type de message NULL) et gère ce cas implicitement.
- créer une table des erreurs de traitement. la nature d'arrière-plan des procédures activées par SSB, il est vraiment difficile de dépanner les erreurs si les messages disparaissent simplement sans trace.
En outre, ce code fait également du code de bonnes pratiques en ce qui concerne la tâche à accomplir (surveillance DBM):
- faire la distinction entre
post_time( quand la notification a-t-elle été envoyée? ), start_time( quand l'action qui a déclenché la notification a-t-elle commencé? ) et processing_time( quand la notification a-t-elle été traitée? ). post_timeet start_timesera probablement identique ou très proche, mais processing_timepeut être en secondes, heures, jours en dehors post_time. le plus intéressant pour l'audit est généralement post_time.
- étant donné que le
post_timeet le processing_timesont différents, il devrait être évident qu'une tâche de surveillance DBM dans une procédure activée par notification régulière n'a aucun intérêt à sys.database_mirroringregarder . Cette vue montrera l' état actuel au moment du traitement, qui peut être lié ou non à l'événement. Si le traitement se produit longtemps après la publication de l'événement (pensez à un arrêt de maintenance), le problème est évident, mais il peut également être traité dans un traitement «sain» si le DBM change d'état très rapidement et publie deux (ou plus) événements dans un ligne (ce qui se produit fréquemment): dans cette situation, le traitement, comme dans le code que vous avez publié, audite l'événement au fur et à mesure qu'il se produit, mais enregistre l'état actuel, final . La lecture d'un tel audit pourrait être très confuse plus tard.
- auditez toujours l'événement XML d'origine. De cette façon, vous pouvez ultérieurement interroger ce XML pour toute information qui n'a pas été «déchiquetée» dans les colonnes de la table d'audit.
Étape 3: attachez la procédure à la file d'attente:
alter queue dbm_notifications_queue
with activation (
status=on,
procedure_name = [dbm_notifications_procedure],
max_queue_readers = 1,
execute as owner);