SQL Avvisa quando stored procedure esegue per troppo tempo

Question

Vorrei impostare uno SQL Server 2008 Alert di notificare me quando qualsiasi procedura eseguita per 1 secondo o più (solo un esempio).

Tutte le idee?

EDIT:

D'accordo, a quanto pare questo non è possibile. Ma, proprio per spingere voi in un'altra direzione, so che ci sono tavoli statistiche nel database master che detengono conti di compilazione, numero di chiamate e altre varie statistiche. Potrei forse periodicamente interrogare loro e poi riferire al riguardo, in qualche modo?

Answer 1

non ci sono notifiche per questo. dovrete impostare una traccia e il polling ogni ora e poi.

Answer 2

Mi piacerebbe aggiungere alla risposta corretta di Mladen Prajdic e di migliorare la risposta kevchadders' da SQL Server Central. La soluzione che propongo di seguito utilizza dbmail invece di SQLMail (che viene utilizzato da soluzione SQLServerCentral mediante chiamata xp_sendmail). Essenzialmente, SQLMail utilizza MAPI ed è più difficile da installare ed dbmail utilizza SMTP ed è più facile da installare. Ecco ulteriori informazioni circa la differenza tra i due.

Non ho potuto ottenere la soluzione di SQL Server Centrale di lavorare in SQL 2005 e la soluzione qui di seguito è stato testato solo sulla mia installazione di SQL 2005 -. YMMV basata sulla versione

In primo luogo, avrete bisogno di una nuova UDF, che si tradurrà l'ID del processo nel ID di processo per un join:

CREATE FUNCTION dbo.udf_SysJobs_GetProcessid(@job_id uniqueidentifier)
RETURNS VARCHAR(8)
AS
BEGIN
    RETURN (substring(left(@job_id,8),7,2) +
    substring(left(@job_id,8),5,2) +
    substring(left(@job_id,8),3,2) +
    substring(left(@job_id,8),1,2))
END

E poi lo sproc:

CREATE PROC sp_check_job_running 
    @job_name char(50),
    @minutes_allowed int, 
    @person_to_notify varchar(50) 

AS 

DECLARE @minutes_running int, 
    @message_text varchar(255)

SELECT @minutes_running = isnull(DATEDIFF(mi, p.last_batch, getdate()), 0)
FROM master..sysprocesses p
JOIN msdb..sysjobs j ON dbo.udf_sysjobs_getprocessid(j.job_id) = substring(p.program_name,32,8)
WHERE j.name = @job_name

IF @minutes_running > @minutes_allowed 
    BEGIN
      SELECT @message_text = ('Job ' + UPPER(SUBSTRING(@job_name,1,LEN(@job_name))) + ' has been running for ' + SUBSTRING(CAST(@minutes_running AS char(5)),1,LEN(CAST(@minutes_running AS char(5)))) + ' minutes, which is over the allowed run time of ' + SUBSTRING(CAST(@minutes_allowed AS char(5)),1,LEN(CAST(@minutes_allowed AS char(5)))) + ' minutes.') 
      EXEC msdb.dbo.sp_send_dbmail
        @recipients = @person_to_notify,
        @body = @message_text,
        @subject = 'Long-Running Job to Check' 
    END

Questa sproc può essere facilmente programmato come un processo di SQL Server Agent o qualsiasi altro metodo necessario. Ci vuole alcuna azione se il lavoro non è in esecuzione o è in esecuzione all'interno di parametri specificati. Si invia l'e-mail se il lavoro è correre più a lungo di quanto specificato.

per es.

EXEC sp_check_job_running 'JobNameGoesHere', 5, 'admin@mycompany.com'

HT: http: //www.sqlserverspecialists. co.uk/blog/_archives/2008/11/26/3996346.html

Answer 3

Se trovato questo su sqlservercentral (probabilmente per una versione precedente di SQL Server, ma ancora potrebbero essere rilevanti al 2008)

procedura di allarme per la lunga corsa di lavoro http://www.sqlservercentral.com/scripts/Lock+and + Collegamento + Gestione / 30144 /

Testo sotto se l'accesso cant.

Per i lavori che vengono eseguiti periodicamente e dovrebbe richiedere solo un breve periodo di tempo per l'esecuzione, un DBA può essere utile sapere quando il lavoro è in corso da un tempo eccessivo. In questo caso, solo il controllo per vedere se il processo è in esecuzione non lo farà; la capacità di assicurarsi che non è stato in esecuzione per un lungo periodo è necessario. Adattamento del id lavoro per un ID di processo in sysprocesses richiede alcune ri-organizzare la id lavoro da fare la partita. Questo script crea una stored procedure che accetta un nome di processo, il tempo di esecuzione massimo consentito, e indirizzo e-mail di notifica. Sarà quindi utilizzare il nome del processo di ri-stringa il numero di posti di lavoro e di controllo sysprocesses (in base al id processo sia parte del nome del programma) per determinare la quantità di tempo il lavoro è stato runing, quindi avviso se quel tempo è finito il "tempo consentito" parametro.

CREATE proc sp_check_job_running
    @job_name       char(50),
    @minutes_allowed    int,
    @person_to_notify   varchar(50)
AS  

DECLARE @var1           char(1),
    @process_id     char(8),
    @job_id_char        char(8),
    @minutes_running    int,
    @message_text       varchar(255)

select @job_id_char = substring(CAST(job_id AS char(50)),1,8) 
from  msdb..sysjobs
where name = @job_name

select @process_id =    substring(@job_id_char,7,2) + 
            substring(@job_id_char,5,2) +
            substring(@job_id_char,3,2) +
            substring(@job_id_char,1,2)


select @minutes_running = DATEDIFF(minute,last_batch, getdate())
from master..sysprocesses
where program_name LIKE ('%0x' + @process_id +'%')

if @minutes_running > @minutes_allowed
  BEGIN
    select @message_text = ('Job ' 
    + UPPER(SUBSTRING(@job_name,1,LEN(@job_name)))
    + ' has been running for '
    + SUBSTRING(CAST(@minutes_running AS char(5)),1,LEN(CAST(@minutes_running AS char(5))))
    + ' minutes, which is over the allowed run time of '
    + SUBSTRING(CAST(@minutes_allowed AS char(5)),1,LEN(CAST(@minutes_allowed AS char(5)))) 
    + ' minutes.')
    EXEC master..xp_sendmail 
    @recipients = @person_to_notify, 
    @message = @message_text,
        @subject = 'Long-Running Job to Check'
  END

--  Typical job step syntax for job to do the checking

execute sp_check_job_running
      'JobThatSHouldBeDoneIn5Minutes', 
       5, 
       'DBAdmin@mycompany.com'

Answer 4

È possibile utilizzare un software di monitoraggio come Nagios contare periodicamente il numero di query lente nel database.

Io personalmente uso la seguente query con l'eccellente PRTG . Ho impostato per inviarmi una e-mail ogni volta che ho più di 5 domande con un tempo di esecuzione maggiore di 3 secondi ciascuna, o quando la query più lenta richiede più di 10 secondi:

SELECT total_elapsed_time / execution_count / 1000000 avg_elapsed_time, execution_count, creation_time, last_execution_time, 
SUBSTRING(st.text, (qs.statement_start_offset/2) + 1, ((CASE statement_end_offset WHEN -1 THEN DATALENGTH(st.text) ELSE qs.statement_end_offset END - qs.statement_start_offset)/2) + 1) AS statement_text
FROM sys.dm_exec_query_stats AS qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st
WHERE total_elapsed_time / execution_count / 1000000 >= 3  -- filter queries that takes > 3 seconds
AND CHARINDEX('dm_exec_query_stats', st.text) = 0   -- In case this query is slow, we don't want it in the result set!
ORDER BY total_elapsed_time / execution_count DESC;

Disclaimer: Questo query si basa su https://stackoverflow.com/a/820252/638040

Ora, se si desidera monitorare i tuoi stored procedure, poi basta usare sys.dm_exec_procedure_stats invece di sys.dm_exec_sql_text (rimuovere anche il creation_time campo dalla selezione e ottimizzare il SUBSTRING su st.text)

Answer 5

È possibile accedere esecuzione di query lente utilizzare SQL Profiler, ma che non si contribuisce con un avviso, in particolare. (Suppongo che si possa accedere ad un file o ad una tabella di database, e avere qualcos'altro "ascoltare" e generare un avviso).

Nel caso in cui non hanno familiarità con SQL Profiler qui sono i passi:

È necessario eseguire SQL Profiler su qualcosa di diverso dal server stesso.

Inizia con il modello SQLProfilerTSQL_Duration

Imposta il filtro: durata: "Maggiore di" per 1000 (milliseonds)

Nei filtri è possibile limitare il database, Login, o simili, se necessario.

Negli eventi è possibile limitare al solo sprocs (di default comprende anche istruzioni SQL)

Answer 6

Se non siete alla ricerca di una soluzione gratuita, si può dare un'occhiata a SQL Sentry . Si fa quello che chiedi e altro ancora.