È possibile registrare i valori dei parametri in arrivo in una chiamata di procedura durante la traccia in SQL Server Profiler?

Utilizzando SQL Server Profiler (sono su SQL Server 2012), sto cercando di generare una traccia utile che mostri i valori dei parametri, non solo l'SQL con nomi di variabili. La procedura memorizzata analizza una grande quantità di dati di inventario per generare risultati estremamente preziosi e sto provando a documentare il comportamento esistente, in modo da poterlo testare l'unità, definirlo esattamente e quindi trasformarlo in qualcosa di sano.

Ho una procedura memorizzata che esegue una sotto-procedura di 54 parametri, all'interno di un ciclo in cui la procedura memorizzata crea un cursore e quindi esegue un ciclo while. Ecco una vista semplificata:

CREATE PROCEDURE 
   [dbo].[OuterProcedure]       
   (  @ProductCode varchar(8),          
     -- 41 more parameters omitted
   )
AS            
  SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED   
  SET NOCOUNT ON           
 DECLARE @AboutFourHundredLocalvariables -- omit about 400 local variable declarations.
 -- OMIT ABOUT 10 temporary table declarations.
 DECLARE  aCursor CURSOR FAST_FORWARD FOR         
   SELECT [ID],bkno,  -- about 40 fields omitted.
              FROM vwVeryComplexViewThatDoesALotOfVeryBrutalJoins         
              WHERE  (about_80_boolean_expressions AND omitted_here)
        ORDER BY some,keys,like,this

OPEN aCursor          
FETCH NEXT FROM aCursor /* Get First Record */         
    INTO @ID, @about_40_fields,.... 
WHILE (@@FETCH_STATUS = 0) AND         
          ( @About80MoreBooleanExpressionsHere)  
BEGIN   /* 1 */            
     -- about 700 lines of logic, math and if-parameter-this-then-that
     -- stuff omitted
            EXEC  @ConsiderItem = 
                      InnerProcedureCallWithinLoop
                                            @from_locn,        
                        @About53PARAMSOMITTED,
                                                ...

    FETCH NEXT FROM CurInventory /* Get Next Record */       
       INTO @ID,@MoreStuff,...    
END                   
CLOSE CurInventory          
DEALLOCATE CurInventory        

Come posso ottenere una traccia per mostrarmi tutti i valori dei parametri passati a InnerProcedureCallWithinLoop? Ci sono 54 parametri. Devo scrivere essenzialmente "54 righe di debug-printfs" nel mio SQL o posso scaricare tutti i valori dei parametri di una chiamata di procedura mentre eseguo una traccia SQL in qualche modo?

Quando ricevo una traccia in questo momento, ottengo questo output:

EXEC  @ConsiderItem = InnerProcedureCallWithinLoop  @from_locn,        
                        @About53ParmsOmitted

Quello che mi piacerebbe sapere è che @from_locn = 1e @About53ParmsOmitted = 'hello world', e così via.

Questo non mi dice il valore reale del parametro @from_locn. Nel caso di quel primo parametro, viene passato alla mia procedura memorizzata di livello superiore, quindi so che è 0 o 1, a seconda del caso. Tuttavia, circa 40 dei 43 parametri in quella procedura interna provengono FETCH NEXT FROM aCursordall'operazione all'interno di un WHILEciclo.

In questo momento la traccia mi dice quante volte InnerProcedureCallWithinLoopviene invocata e quanto tempo impiega ciascuna, ma non quali sono stati i valori dei parametri di quella chiamata. Se potessi in qualche modo ottenere "script SQL autonomi eseguibili" che replicano alcuni casi angolari che trovo nel mio codice, mentre traccio questi script, impostando queste funzioni grossolane (lo so, 54 parametri, è davvero grossolano, ma non ho scritto loro!) potrebbe volermi un'ora di digitazione solo per creare uno script SQL che mi permetta di invocare questo caso angolare, al di fuori di questo grande gargarismo delle procedure memorizzate di SQL Server.

Tutto questo fa parte di uno sforzo per analizzare in dettaglio un'espressione SQL e creare script in grado di sondare queste complesse procedure memorizzate.

Aggiornamento Ho trovato un'opzione di registrazione "Output Param" RPC, ma non un'opzione di registrazione "RPC IN PARAM".

Morderò il proiettile e ti dirò che una tale traccia non può essere impostata, perché non è lo scopo [percepito] delle tracce. L'ho sempre fatto in questo modo:

WHILE (@@ FETCH_STATUS = 0) AND
            (@ About80MoreBooleanExpressionsHERE) INIZIA
/ * 1 * /
    - circa 700 righe di logica, matematica e if-parametro-this-then-that
    - roba omessa
      INSERT InnerProcedureCallWithinLoop__TraceTable
              VALUES (@from_locn, @ About53PARAMSOMITTED
      EXEC @ConsiderItem =
            InnerProcedureCallWithinLoop
                  @from_locn,
                        @ About53PARAMSOMITTED,
...

Se so che viene chiamato solo da una posizione. Altrimenti, lo faccio nella chiamata invece del chiamante.

ALTER PROC InnerProcedureCallWithinLoop
    @from_locn int,
    @About53PARAMSOMITTED ...
AS
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SET NOCOUNT ON;
INSERT InnerProcedureCallWithinLoop__TraceTable VALUES (@from_locn, @prm2, @prm3....
--- rest of proc

Ciò è ovviamente diverso dall'uso di una traccia, che è in grado di acquisire eventi anche se avviati e mai terminati (parametri errati, rollback delle transazioni). Se questo è il tuo problema, devi esaminare i metodi CLR o e-mail per esternalizzare l'output acquisito.