c# - noticeerror - Ignorar conexiones de SignalR persistentes en New Relic

new relic notice error java

Question

¿Dónde debo llamar a NewRelic.Api.Agent.NewRelic.IgnoreApdex() o NewRelic.Api.Agent.NewRelic.IgnoreTransaction() en mis concentradores de SignalR para evitar que las conexiones persistentes de larga duración superen mis registros de monitoreo de aplicaciones?

Answer 1

En SignalR.Core 2.2.2 hay dos métodos AuthorizeRequest. Así que el archivo de instrumento New Relic debería tener este aspecto:

<?xml version="1.0" encoding="utf-8"?>
<extension xmlns="urn:newrelic-extension">
    <instrumentation>
        <tracerFactory name="NewRelic.Agent.Core.Tracer.Factories.IgnoreTransactionTracerFactory">
            <match assemblyName="Microsoft.AspNet.SignalR.Core" className="Microsoft.AspNet.SignalR.PersistentConnection">
                <exactMethodMatcher methodName="AuthorizeRequest"/>
            </match>
             <match assemblyName="Microsoft.AspNet.SignalR.Core" className="Microsoft.AspNet.SignalR.Hubs.HubDispatcher">
                <exactMethodMatcher methodName="AuthorizeRequest"/>
            </match>
        </tracerFactory>
    </instrumentation>
</extension>

Resolver este problema en "C: / ProgramData / New Relic.NET Agent / Extensions" resuelve el problema.

Answer 2

Es posible ignorar una transacción a través de una instrumentación personalizada, así como usar IgnoreTransactionTracerFactory. Esto es particularmente útil cuando no desea agregar la API a su proyecto o cuando desea ignorar transacciones basadas en un método de Marco que no puede cambiar.

Su archivo de instrumentación personalizado se vería como:

<?xml version="1.0" encoding="utf-8"?>
<extension xmlns="urn:newrelic-extension">
  <instrumentation>
    <tracerFactory name="NewRelic.Agent.Core.Tracer.Factories.IgnoreTransactionTracerFactory">
      <match assemblyName="System.Web.Extensions" className="System.Web.Handlers.ScriptResourceHandler">
        <exactMethodMatcher methodName="Throw404" />
      </match>
    </tracerFactory>
  </instrumentation>
</extension>

Si puede encontrar un método de marco SignalR al que siempre se llama en el subproceso de solicitud (solo puede llamar a IgnoreTransaction en el subproceso de solicitud, no en un subproceso asíncrono), puede completar el assemblyName / className / methodName como se muestra arriba. lo mismo que llamar a la API IgnoreTransaction dentro de ese método.

Answer 3

Oh, gran pregunta y una en la que no había pensado todavía. Creo que lo que tendría que hacer es escribir un módulo personalizado, ya que los módulos se ejecutan antes que todos los controladores, que detectan que el controlador SignalR AspNetHandler es el que se solicita y, si es así, llama a los métodos NewRelic IgnoreXXX en ese momento.

Solo spitballing (por ejemplo, no he probado esto) ese módulo podría tener este aspecto:

public class SignalRNewRelicIgnoreHttpModule : IHttpModule
{
    public void Init(HttpApplication context)
    {
        context.PostMapRequestHandler += (s, a) =>
            {
                if(HttpContext.Current.Handler is SignalR.Hosting.AspNet.AspNetHandler)
                {
                    NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
                }
            };
    }

    public void Dispose()
    {

    }
}

Entonces (¿obviamente?) Necesitas registrar ese módulo en la configuración como así ...

Modo integrado de IIS:

<configuration>
  <system.webServer>
    <modules>
        <add name="SignalRNewRelicIgnoreHttpModule" type="WhateverNamespace.SignalRNewRelicIgnoreHttpModule, WhateverAssemblyName" />
    </modules>
   </system.webServer>
</configuration>

Modo clásico de IIS:

<configuration>
    <system.web>
        <httpModules>
            <add name="SignalRNewRelicIgnoreHttpModule" type="WhateverNamespace.SignalRNewRelicIgnoreHttpModule, WhateverAssemblyName" />
        </httpModules>
    </system.web>
</configuration>

ACTUALIZACIÓN: 5/25/2013

Como lo advirtió @dfowler en los comentarios, SignalR ha cambiado su enfoque del hosting y ahora, en cambio, ahora se basa en el Owin basado en Owin . Esto es genial porque desacopla SignalR directamente de ASP.NET/IIS, pero eso significa que el enfoque anterior obviamente ya no funcionará. En su lugar, lo que debería hacer es asegurarse de configurar la canalización de Owin con un módulo como el que se muestra a continuación (también disponible aquí en forma resumida ) para deshabilitar el seguimiento de la tubería:

public class NewRelicIgnoreTransactionOwinModule
{
    private AppFunc _nextAppFunc;

    public NewRelicIgnoreTransactionOwinModule(AppFunc nextAppFunc)
    {
        _nextAppFunc = nextAppFunc;
    }

    public Task Invoke(IDictionary<string, object> environment)
    {
        // Tell NewRelic to ignore this particular transaction
        NewRelic.Api.Agent.NewRelic.IgnoreTransaction();

        return _nextAppFunc(environment);
    }
}

Y luego, en su Método de configuración de Inicio :: simplemente asegúrese de agregar este módulo a IAppBuilder antes de asignar cualquier conexión / hub de SignalR. Eso debería verse algo como esto:

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        app.Use(typeof(NewRelicIgnoreTransactionOwinModule));
        app.MapHubs();
    }
}

Finalmente, debe tenerse en cuenta que, en este momento, esto requiere un enfoque muy simplista que asume que no va a tener ninguna otra solicitud de Owin en el ámbito de su aplicación. Si está mezclando SignalR en otra aplicación web que tiene otras solicitudes de Owin, la implementación de este módulo en particular también provocará que se ignoren, por lo que se requerirá un módulo más avanzado que tal vez compruebe que la solicitud entrante está apuntando a una URL de SignalR. Por ahora, le dejo eso al lector para que lo descubra.

Answer 4

Para continuar con la respuesta de Micah, aquí está el archivo de instrumentación personalizado para ignorar todas las llamadas de señal.

Créelo en C: / ProgramData / New Relic.NET Agent / Extensions / IgnoreSignalR.xml

<?xml version="1.0" encoding="utf-8"?>
<extension xmlns="urn:newrelic-extension">
    <instrumentation>

        <!-- Optional for basic traces. -->
        <tracerFactory name="NewRelic.Agent.Core.Tracer.Factories.IgnoreTransactionTracerFactory">
            <match assemblyName="Microsoft.AspNet.SignalR.Core" className="Microsoft.AspNet.SignalR.PersistentConnection">
                <exactMethodMatcher methodName="ProcessRequest"/>
            </match>
        </tracerFactory>
    </instrumentation>
</extension>

Recuerda hacer iisreset.

Answer 5

Para las personas que usan una versión antigua de SignalR, aquí está la instrumentación xml.

<tracerFactory name="NewRelic.Agent.Core.Tracer.Factories.IgnoreTransactionTracerFactory">
    <match assemblyName="SignalR.Hosting.AspNet" className="SignalR.Hosting.AspNet.AspNetHandler">
        <exactMethodMatcher methodName="ProcessRequestAsync"/>
    </match>
</tracerFactory>

Answer 6

Todo este problema parece ser causado por el método de "conexión" en el controlador SignalR. Creé un módulo de canalización de hub que ignora el registro de NewRelic al invalidar el método OnBeforeConnect.

En algún lugar después de que los maphubs llamen a su método Application_Start () (global.asax.cs) para su aplicación web, agregue lo siguiente:

GlobalHost.HubPipeline.AddModule(new IgnoreNewRelicConnectionsModule());

Entonces crea esta clase:

private class IgnoreNewRelicConnectionsModule : HubPipelineModule
{
    protected override bool OnBeforeConnect(IHub hub)
    {
        NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
        return base.OnBeforeConnect(hub);
    }

}

Answer 7

    public Task Invoke(IDictionary<string, object> environment)
    {
        object value = "";

        //Check if the OWIN key is present
        if (environment.ContainsKey("owin.RequestPath"))
        {
            //Get the value of the key
            environment.TryGetValue("owin.RequestPath", out value);
            //This will block all signalr request, but we can configure according to requirements
            if (value.ToString().Contains("/signalr"))
            {
                // Tell NewRelic to ignore this particular transaction
                NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
                NewRelic.Api.Agent.NewRelic.IgnoreApdex();
            }
        }
        return _nextAppFunc(environment);
    }