Developpez.com

Télécharger gratuitement le magazine des développeurs, le bimestriel des développeurs avec une sélection des meilleurs tutoriels

Création de fichiers de trace SQL Server Profiler côté serveur

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

S'il est bien un outil qu'il est confortable d'utiliser pour rechercher des problèmes de performances sur un serveur de bases de données SQL Server, c'est bien le Profiler de SQL Server.

En effet cette interface graphique permet de capturer des données d'événements qui se produisent au sein d'une instance SQL Server, et des les analyser directement dans l'interface proposée, ou ultérieurement en enregistrant la trace dans un fichier.


Nous allons voir ici comment :

  • créer une trace de façon automatique à l'aide de l'Agent SQL Server,
  • l'arrêter, toujours de façon automatique,
  • la charger automatiquement dans une table de base de données
  • séparer les fichiers de trace par période (par exemple un fichier par heure).

II. Préparation de la trace

Démarrons SQL Server Management Studio, puis rendons-nous dans le menu Outils pour démarrer SQL Server Profiler:

image


Nous obtenons l'interface graphique sous laquelle nous pouvons suivre, entre autres, les exécutions de quelques appels de procédures stockées :

image


Il suffit de choisir les événements habituels.

Dans cet exemple, nous sélectionnerons :

  • RPC : Completed
  • Locks : Deadlock Graph
  • Locks : Timeout (timeout > 0)


Voyons tout d'abord RPC : Completed : nous voulons savoir combien de pages les procédures stockées appelées lisent et écrivent, et combien de temps celles-ci mettent à s'exécuter. Nous souhaitons également connaitre le nom des procédures stockées.

image


Nous cochons seulement les cases dont nous avons besoin, de façon à minimiser la charge que la trace s'appropriera :

  • TextData pour le code d'appel complet de la procédure stockée,
  • Reads pour le nombre de pages lues à l'exécution de la procédure stockée,
  • Writes pour le nombre de pages écrites à l'exécution de la procédure stockée,
  • Duration pour le temps d'exécution total de la procédure stockée,
  • StartTime pour savoir à quelle heure la procédure stockée s'est exécutée.


Réduisons maintenant le détail de toutes les catégories de classes d'événement :

image


Passons ensuite aux verrous et étreintes mortelles, après avoir coché la case Afficher tous les événements. En développant le noeud de la catégorie Locks, nous obtenons :

image


Notons ici que quel que pour n'importe quel événement, la colonne SPID (identifiant de la session qui a déclenché l'événement) est cochée et ne peut être décochée tant que l'événement associé est actif.


Ajoutons maintenant les filtres :

image


Nous obtenons alors la boîte de dialogue suivante :

image


. et nous pouvons filtrer sur le paramètre correspondant au nombre de pages lues. Ici nous choisissions 100, c'est-à-dire 8Mo.

Il suffit maintenant de démarrer la trace, comme si nous voulions la visualiser dans l'interface graphique :

image

III. Obtention du script de trace SQL Server Profiler

Pour obtenir le script de la trace que nous venons de créer, il suffit d'ouvrir le menu Fichier:

image


. et de choisir finalement de générer un script de trace pour l'édition de SQL Server qui convient.

On retrouve la boîte de dialogue d'enregistrement classique d'un fichier :

image


L'enregistrement est immédiatement confirmé :

image


N'oublions pas d'arrêter la trace avant de quitter SQL Server Profiler :

image


Retournons maintenant sous SQL Server Management Studio, puis ouvrons le fichier script de trace :

image


Nous obtenons alors le script suivant :

 
Sélectionnez

/****************************************************/
/* Created by: SQL Server 2008 Profiler             */
/* Date: 07/10/2009  23:03:19         */
/****************************************************/
 
 
-- Create a Queue
declare @rc int
declare @TraceID int
declare @maxfilesize bigint
set @maxfilesize = 5 
 
-- Please replace the text InsertFileNameHere, with an appropriate
-- filename prefixed by a path, e.g., c:\MyFolder\MyTrace. The .trc extension
-- will be appended to the filename automatically. If you are writing from
-- remote server to local drive, please use UNC path and make sure server has
-- write access to your network share
 
exec @rc = sp_trace_create @TraceID output, 0, N'InsertFileNameHere', @maxfilesize, NULL 
if (@rc != 0) goto error
 
-- Client side File and Table cannot be scripted
 
-- Set the events
declare @on bit
set @on = 1
exec sp_trace_setevent @TraceID, 148, 12, @on
exec sp_trace_setevent @TraceID, 148, 14, @on
exec sp_trace_setevent @TraceID, 148, 1, @on
exec sp_trace_setevent @TraceID, 189, 1, @on
exec sp_trace_setevent @TraceID, 189, 12, @on
exec sp_trace_setevent @TraceID, 189, 13, @on
exec sp_trace_setevent @TraceID, 189, 14, @on
exec sp_trace_setevent @TraceID, 10, 16, @on
exec sp_trace_setevent @TraceID, 10, 1, @on
exec sp_trace_setevent @TraceID, 10, 17, @on
exec sp_trace_setevent @TraceID, 10, 12, @on
exec sp_trace_setevent @TraceID, 10, 13, @on
exec sp_trace_setevent @TraceID, 10, 14, @on
 
-- Set the Filters
declare @intfilter int
declare @bigintfilter bigint
 
set @bigintfilter = 100
exec sp_trace_setfilter @TraceID, 16, 0, 4, @bigintfilter
 
-- Set the trace status to start
exec sp_trace_setstatus @TraceID, 1
 
-- display trace id for future references
select TraceID=@TraceID
goto finish
 
error: 
select ErrorCode=@rc
 
finish: 
go

IV. Interprétation du fichier de script de trace

Le premier appel de procédure stockée est sp_trace_create. Il permet simplement de créer la trace.

Je vous engage à vous documenter sur les paramètres de cette procédure stockée système :


Ensuite la procédure stockée sp_trace_setevent est appelée plusieurs fois, à raison d'une fois par événement. En consultant la documentation de cette procédure stockée, on voit que :

  • Pour tout événement, on doit passer l'identifiant de trace, que l'on retrouve en requêtant la table sys.traces
  • Chaque événement possède un identifiant qui doit être passé en second paramètre d'entrée à cette procédure stockée. Il existe en tout plus de 200 événements, à savoir :ID 148 qui correspond à l'événement Deadlock GraphID 189 qui correspond à l'événement Lock:Timeout (timeout> 0)ID 10 qui correspond à l'événement RPC:Completed
  • Pour chaque événement, on doit préciser les colonnes qui devront être prises en compte.

On retrouvera forcément, pour chacun des événements, comme nous l'avons vu, la colonne n° 12, qui correspond au SPID, et en l'occurrence :

  • La colonne n° 14, qui correspond à la colonne StartTime,
  • La colonne n° 1, qui identifie la colonne TextData,
  • La colonne n° 13, pour la colonne Duration,
  • La colonne n° 16, pour la colonne Reads, que l'on ne trouve que pour l'événement RPC:Completed,
  • La colonne n° 17, pour la colonne Writes, également seulement pour l'événement RPC:Completed.


On peut ensuite spécifier des filtres avec la procédure sp_trace_setfilter et, comme nous avons spécifié dans l'interface graphique, un filtre sur les appels de procédures qui provoquent la lecture de plus de 100 pages. Nous trouvons, dans l'ordre :

  • Toujours l'identifiant de trace,
  • L'identifiant de la colonne à filtrer, ici la n° 16 : Reads
  • L'opérateur logique AND(0) ou OR (1), car on peut spécifier plusieurs filtres pour la même colonne, par exemple les procédures entraînent la lecture d'au moins 100 pages et d'au plus 1000 pages, ou les procédures dont le nom contient un mot ou un autre
  • Le dernier paramètre est de type BIT et permet d'activer ou désactiver le filtre à volonté, en appelant tout simplement cette même procédure stockée avec ce paramètre à 0, ce qui est envisageable même si la trace est en cours d'exécution.

V. Ecriture de la procédure stockée de création de trace

Voici le script complet de gestion des fichiers de trace.


Il est commenté autant que cela est possible, et permet :

  • De créer des fichiers pour une trace ayant les mêmes caractéristiques (événements, filtres)
  • D'intégrer le fichier de trace précédent dans une table dbo.maTableDeTrace (script suivant) dont le script de création suit celui-ci, à l'aide de la fonction table fn_trace_gettable. A noter que l'on n'est pas obligé d'intégrer les fichiers dans une table.
  • De supprimer les fichiers de trace que l'on vient d'intégrer
 
Sélectionnez

-------------------------------
-- 12/10/2009 - Nicolas SOUQUET
-------------------------------
ALTER PROCEDURE PsCreeTrace
	@_cheminFichierTrace NVARCHAR(256),
	@_minutesTrace SMALLINT,	-- Spécifie le nombre de minutes de durée de la trace <=> périodocité de de renouvellement des fichiers de la trace
	@_avecDetails BIT = 0,		-- Retourne quelques caractéristiques de la trace créée
	@_avecIntegration BIT = 0	-- Intègre le fichier de trace précedémment créé directement de base de données locale
AS
BEGIN
	SET NOCOUNT ON
	--	
	BEGIN TRY
		DECLARE @IDTrace INT,
				@IDTraceToStop INT,
				@cheminFichierTraceToStop NVARCHAR(256),
				@timestampFichierTrace NCHAR(15),
				@maxFileSize BIGINT,
				@errMsg NVARCHAR(2047),
				@DOS VARCHAR(255)
 
		-- Vérifie que le chemin du fichier est :
		-- - soit un fichier d'un dossier local
		-- - soit un fichier d'un partage réseau
		IF
		(
			@_cheminFichierTrace NOT LIKE '_:\%' -- Répertoire local
			AND @_cheminFichierTrace NOT LIKE '\\%\%' -- Chemin UNC
		)
		BEGIN
			RAISERROR('Chemin de fichier de trace incorrect ("C:\monRepertoire\maTrace.trc" ou "\\monServeur\monRepertoirePartagé\monRepertoire\maTrace.trc"', 16, 1)
		END
 
		-----------------------------------------
		-- Gestion des traces précedemment créées
		-----------------------------------------
		-- Recherche s'il existe une trace de même nom de fichier (mais avec un "timestamp" différent)
		-- Arrête cette trace le cas échéant
		SELECT @IDTraceToStop = id,
				@cheminFichierTraceToStop = path
		FROM sys.traces
		WHERE path LIKE '%' + @_cheminFichierTrace + '%'
 
		IF @IDTraceToStop IS NOT NULL
		BEGIN			
			-- >>>>> ATTENTION ceci ne supprime pas le fichier de trace
			DECLARE @codeRetourArretTrace TINYINT
 
			 -- Arrête la trace
			EXEC @codeRetourArretTrace = sys.sp_trace_setstatus @IDTraceToStop, 0
			IF @codeRetourArretTrace = 0
			BEGIN
				-- Ferme la trace et supprime sa définition du serveur.
				EXEC @codeRetourArretTrace = sys.sp_trace_setstatus @IDTraceToStop, 2
			END
			ELSE
			BEGIN
				SET @errMsg = CASE @codeRetourArretTrace
									WHEN 1 THEN 'Erreur inconnue'
									WHEN 8 THEN 'L''état spécifié n''est pas valide'
									WHEN 9 THEN 'Le descripteur de trace spécifié n''est pas valide'
									WHEN 13 THEN 'Mémoire insuffisante'
								END
 
				RAISERROR('Problème lors de l''arrêt de la trace %s : %s', 16, 1, @_cheminFichierTrace, @errMsg)
			END
 
			-- Intègre le fichier dans une table de trace, le cas échéant
			IF
			(
				@codeRetourArretTrace = 0
				AND @_avecIntegration = 1
			)
			BEGIN
				INSERT INTO dbo.maTabledeTrace
				SELECT *
				FROM sys.fn_trace_gettable(@cheminFichierTraceToStop, NULL)
 
				-- Si l'intégration s'est bien passée, suppression du fichier de trace
				IF @@ERROR = 0
				BEGIN
					SET @DOS = 'DEL ' + @cheminFichierTraceToStop
 
					PRINT @DOS
 
					EXEC master.dbo.xp_cmdshell @DOS, NO_OUTPUT -- A remplacer par l'appel à une procédure stockée d'assembly
				END
			END
		END	
 
		-- Supprime l'extension de fichier de trace
		-- celle-ci est automatiquement ajoutée à la création de la trace
		IF RIGHT(@_cheminFichierTrace, 4) = '.trc'
		BEGIN
			SELECT @_cheminFichierTrace = REPLACE(@_cheminFichierTrace, '.trc', '')
		END
 
		-- Calcule un "timestamp" pour le nom du fichier de trace (Format : YYYYMMDD_HHmmss)
		SELECT @timestampFichierTrace = CONVERT(NCHAR(8), GETDATE(), 112) + '_' +
										REPLACE(CONVERT(NVARCHAR(10), GETDATE(), 108), ':', ''),
										@maxFileSize = 200 -- taille maximale du fichier de trace, en Mo
 
		-- Concatène le nom du fichier de trace avec le "timestamp"
		SET @_cheminFichierTrace = @_cheminFichierTrace + @timestampFichierTrace
 
		-----------------------
		-- Création de la trace
		-----------------------
		-- Calcule l'heure d'arrêt de la trace
		DECLARE @heureArretTrace DATETIME
		SELECT @heureArretTrace = DATEADD(minute, @_minutesTrace, GETDATE())
 
		EXEC sys.sp_trace_create
			@IDTrace OUTPUT, -- nécessaire pour paramétrer la trace par la suite
			0, -- permet de spécifier quelques options. Voir la BOL.
			@_cheminFichierTrace, -- l'extension .trc est automatiquement ajoutée
			@maxFileSize,
			@heureArretTrace,
			NULL -- nombre maximal de fichiers pour la même trace
 
		-----------------------------
		-- Attachement des événements
		-----------------------------
		-- Permet à posteriori de désactiver un événement
		-- alors que la trace est toujours ne cours d'exécution
		-- en passant 0 en dernier paramètre à sys.sp_trace_setevent
		DECLARE @actif BIT SET @actif = 1
 
		-- Evénement : Deadlock graph
		EXEC sys.sp_trace_setevent @IDTrace, 148, 1, @actif
		EXEC sys.sp_trace_setevent @IDTrace, 148, 12, @actif	-- colonne SPID, obligatoire
		EXEC sys.sp_trace_setevent @IDTrace, 148, 14, @actif	-- colonne StartTime
 
		-- Evénement : Lock:Timeout (timeout> 0)
		EXEC sys.sp_trace_setevent @IDTrace, 189, 1, @actif		-- colonne TextData
		EXEC sys.sp_trace_setevent @IDTrace, 189, 12, @actif	-- colonne SPID, obligatoire
		EXEC sys.sp_trace_setevent @IDTrace, 189, 13, @actif	-- colonne Duration
		EXEC sys.sp_trace_setevent @IDTrace, 189, 14, @actif	-- colonne StartTime
 
		-- Evénement : RPC:Completed
		EXEC sys.sp_trace_setevent @IDTrace, 10, 1, @actif		-- colonne TextData
		EXEC sys.sp_trace_setevent @IDTrace, 10, 12, @actif		-- colonne SPID, obligatoire
		EXEC sys.sp_trace_setevent @IDTrace, 10, 13, @actif		-- colonne Duration
		EXEC sys.sp_trace_setevent @IDTrace, 10, 14, @actif		-- colonne StartTime
		EXEC sys.sp_trace_setevent @IDTrace, 10, 16, @actif		-- colonne Reads
		EXEC sys.sp_trace_setevent @IDTrace, 10, 17, @actif		-- colonne Writes
 
		-----------------------------------
		-- Ajout des filtres aux événements
		-----------------------------------		
		-- Le type de la valeur à filtrer doit correspondre à celui de la colonne
		-- pour trouver le type de la colonne, voir plus loin
		-- Ici, le type de la colonne "Reads" est BIGINT
		DECLARE @bigintFilter BIGINT SET @bigintFilter = 100
 
		EXEC sys.sp_trace_setfilter
			@IDTrace,		-- identifiant de la trace
			16,				-- colonne de la trace
			0,				-- AND : 0 | 1 : OR
			4,				-- >=
			@bigintFilter	-- valeur du filtre
 
		------------------------
		-- Démarrage de la trace
		------------------------
		EXEC sys.sp_trace_setstatus @IDTrace, 1
 
		-------------------------------------------------
		-- Affiche éventuellement les détails de la trace
		-------------------------------------------------
		IF @_avecDetails = 1
		BEGIN
			SELECT id,
					CASE status
						WHEN 0 THEN 'Arrêtée'
						WHEN 1 THEN 'Démarrée'
					END AS Statut,
					path AS Emplacement,
					stop_time AS DateHeureArret
			FROM sys.traces
			WHERE id = @IDTrace
		END
	END TRY
	BEGIN CATCH
		IF EXISTS
		(
			SELECT *
			FROM sys.traces
			WHERE id = @IDTrace
		)
		BEGIN
			DECLARE @arretTraceOK BIT = 0
			BEGIN TRY
				-- >>>>> ATTENTION ceci ne supprime pas le fichier de trace
				EXEC sys.sp_trace_setstatus @IDTrace, 0 -- Arrête la trace
				EXEC sys.sp_trace_setstatus @IDTrace, 2 -- Ferme la trace et supprime sa définition du serveur.
 
				SET @arretTraceOK = 1
			END TRY
			BEGIN CATCH
				RAISERROR('Erreur à l''arrêt de la trace %s',16, 1, @_cheminFichierTrace)
			END CATCH
 
			IF @arretTraceOK = 1
			BEGIN
				-- Suppression du fichier de trace éventuel
				SET @DOS = 'DEL ' + @_cheminFichierTrace
				EXEC master.dbo.xp_cmdshell @DOS, NO_OUTPUT
 
				PRINT 'Arrêt de la trace ' + @_cheminFichierTrace + 'effectué '
			END
		END		
		-- Re-lève l'exception
		SET @errMsg = ERROR_MESSAGE()
		RAISERROR(@errMsg, 16, 1)
	END CATCH
END

V-A. Script de création de la table d'intégration des traces

 
Sélectionnez

USE maBD
GO
CREATE TABLE dbo.maTableDeTrace
(
	TextData ntext NULL,
	BinaryData image NULL,
	DatabaseID int NULL,
	TransactionID bigint NULL,
	LineNumber int NULL,
	NTUserName nvarchar(256) NULL,
	NTDomainName nvarchar(256) NULL,
	HostName nvarchar(256) NULL,
	ClientProcessID int NULL,
	ApplicationName nvarchar(256) NULL,
	LoginName nvarchar(256) NULL,
	SPID int NULL,
	Duration bigint NULL,
	StartTime datetime NULL,
	EndTime datetime NULL,
	Reads bigint NULL,
	Writes bigint NULL,
	CPU int NULL,
	Permissions bigint NULL,
	Severity int NULL,
	EventSubClass int NULL,
	ObjectID int NULL,
	Success int NULL,
	IndexID int NULL,
	IntegerData int NULL,
	ServerName nvarchar(256) NULL,
	EventClass int NULL,
	ObjectType int NULL,
	NestLevel int NULL,
	State int NULL,
	Error int NULL,
	Mode int NULL,
	Handle int NULL,
	ObjectName nvarchar(256) NULL,
	DatabaseName nvarchar(256) NULL,
	FileName nvarchar(256) NULL,
	OwnerName nvarchar(256) NULL,
	RoleName nvarchar(256) NULL,
	TargetUserName nvarchar(256) NULL,
	DBUserName nvarchar(256) NULL,
	LoginSid image NULL,
	TargetLoginName nvarchar(256) NULL,
	TargetLoginSid image NULL,
	ColumnPermissions int NULL,
	LinkedServerName nvarchar(256) NULL,
	ProviderName nvarchar(256) NULL,
	MethodName nvarchar(256) NULL,
	RowCounts bigint NULL,
	RequestID int NULL,
	XactSequence bigint NULL,
	EventSequence bigint NULL,
	BigintData1 bigint NULL,
	BigintData2 bigint NULL,
	GUID uniqueidentifier NULL,
	IntegerData2 int NULL,
	ObjectID2 bigint NULL,
	Type int NULL,
	OwnerID int NULL,
	ParentName nvarchar(256) NULL,
	IsSystem int NULL,
	Offset int NULL,
	SourceDatabaseID int NULL,
	SqlHandle image NULL,
	SessionLoginName nvarchar(256) NULL,
	PlanHandle image NULL,
	GroupID int NULL
)

V-B. Structure de la table de trace

Nom de la colonne Type de données Nom de la colonne Type de données
ApplicationName nvarchar NTUserName nvarchar
BigintData1 bigint ObjectID int
BigintData2 bigint ObjectID2 bigint
BinaryData image ObjectName nvarchar
ClientProcessID int ObjectType int
ColumnPermissions int Offset int
CPU int OwnerID int
DatabaseID int OwnerName nvarchar
DatabaseName nvarchar ParentName nvarchar
DBUserName nvarchar Permissions bigint
Duration bigint PlanHandle image
EndTime datetime ProviderName nvarchar
Error int Reads bigint
EventClass int RequestID int
EventSequence bigint RoleName nvarchar
EventSubClass int RowCounts bigint
FileName nvarchar ServerName nvarchar
GroupID int SessionLoginName nvarchar
GUID uniqueidentifier Severity int
Handle int SourceDatabaseID int
HostName nvarchar SPID int
IndexID int SqlHandle image
IntegerData int StartTime datetime
IntegerData2 int State int
IsSystem int Success int
LineNumber int TargetLoginName nvarchar
LinkedServerName nvarchar TargetLoginSid image
LoginName nvarchar TargetUserName nvarchar
LoginSid image TextData ntext
MethodName nvarchar TransactionID bigint
Mode int Type int
NestLevel int Writes bigint
NTDomainName nvarchar XactSequence bigint


V-C. Script d'activation de la procédure stockée système étendue xp_cmdshell

Même si son utilisation n'est pas recommandée pour des raisons évidentes de sécurité, voici un script qui permet d'activer l'utilisation de la procédure stockée système étendue xp_cmdshell :

 
Sélectionnez

IF EXISTS
(
	SELECT *
	FROM sys.configurations
	WHERE name = 'xp_cmdshell'
	AND value_in_use = 0
)
BEGIN
	EXEC sys.sp_configure 'show advanced options', '1'
	RECONFIGURE
 
	EXEC sys.sp_configure 'xp_cmdshell', '1'
	RECONFIGURE
 
	EXEC sys.sp_configure 'show advanced options', '0'
	RECONFIGURE
END

VI. Création du job de création des fichiers de trace

Retournons sous SQL Server Management Studio pour créer le travail qui permettra d'exécuter la procédure stockée de création des traces :

image

Ajoutons quelques commentaires :

image


Passons à l'ajout d'une nouvelle étape :

image


Il faut que la base de données soit la même que celle qui héberge la table dbo.matableDeTrace.

Ici nous créerons un fichier de trace par heure :

image


Passons à la planification du job :

image


Il faut veiller à spécifier la même fréquence que la périodicité de renouvellement des fichiers de trace (paramètre @_minutesTrace)

image

Validons la planification par OK :

image


Un nouveau clic sur le bouton OK entraîne la création du job :

image

VII. Exploitation des données de trace

Nous trouvons le fichier de trace courant :

image


Si nous interrogeons directement la table dbo.maTableDeTrace, nous verrons qu'il y a des nombreuses colonnes sans valeur (NULL) : en effet, nous avons utilisé 6 colonnes pour notre trace, mais le fichier de trace en contient un total de 66.


Voici donc un petit script qui permet une consultation facile des données contenues dans la table d'intégration de la trace, à l'aide de la fonction de table système fn_trace_geteventinfo, qui donne la liste des colonnes utilisées par la trace :

 
Sélectionnez

DECLARE @req VARCHAR(256) SET @req = 'SELECT '
 
;WITH
	CTE_COLONNES_TRACE AS
	(
		SELECT DISTINCT columnid
		FROM sys.fn_trace_geteventinfo(2)
	)
SELECT @req = @req + C.name + ','
FROM sys.tables AS T
JOIN sys.columns AS C
	ON T.object_id = C.object_id
JOIN CTE_COLONNES_TRACE AS CCT
	ON C.column_id = CCT.columnid
WHERE T.name = 'maTableDeTrace'
 
SET @req = LEFT(@req, LEN(@req) - 1) + ' FROM dbo.maTableDeTrace'
EXEC (@req)
image

VIII. Conclusion

SQL Server fournit un ensemble de procédures stockées et de fonctions système qu'il est simple d'intégrer dans une procédure stockée utilisateur pour gérer des fichiers de trace. Il est également possible d'en conserver plusieurs sans pour autant les intégrer en base de données, et de combiner l'utilisation de ces modules consacrés aux traces avec un job SQL Server.


La génération d'un script de trace est une opération simple depuis l'interface du profiler SQL Server. Il est donc nécessaire de connaître son fonctionnement afin de pouvoir analyser l'utilisation et le comportement d'une base de données SQL Server].

IX. Remerciements

  • David Barbarin pour la relecture de cet article,
  • Fleur-Anne Blain qui m'a supporté pour la publication
  • Toute l'équipe de Développez

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2009 Nicolas SOUQUET. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.