IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

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 nœud de la catégorie Locks, nous obtenons :

image


Notons ici 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 8 Mo.

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. Écriture 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. À 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ériodicité 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écédemment 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écédemment 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 a 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
 
        -- Évé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
 
        -- Évé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 connaitre 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 ni 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.