c# - porta - Registro de funciones de Azure mediante TraceWriter en una biblioteca externa

porta azure

Question

¿Cómo puedo reutilizar el objeto TraceWriter disponible en una función azul para registrar información en una biblioteca con referencia externa? Intenté pasar el objeto usando el constructor y hacer referencia a la clase TraceWriter (web.http.tracing). No tuve suerte ya que las clases parecen diferentes.

Answer 1

Como actualización, Azure Functions ahora admite el consumo de un ILogger lugar de TraceWritter para que pueda consumir cualquier marco de registro que implemente ILogger .

Vea el tema de GitHub y la documentación wiki subsiguiente.

Answer 2

Si estoy en lo correcto, las versiones necesarias para que ILogger funcione con las funciones de Azure serían Microsoft.Azure.WebJobs 2.1.0-beta1. Sin embargo, parece que no puedo ejecutar una función de Azure con un ILogger en lugar de un TraceWriter.

También hay muy poca información y documentación disponible sobre el desarrollo de las funciones de Azure utilizando ILogger. ¿Alguien tiene más información o consejos para que esto funcione?

Mi fragmento de código C #:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.ServiceBus;
using System;
using Newtonsoft.Json;
using Microsoft.Extensions.Logging;

namespace Experimental.Functions
{
    public static class ListenToEventFunction
    {
        [FunctionName("ListenToEventFunction")]
        public static void Run([EventHubTrigger("events", Connection = "EventHubConnectionString")]string myEventHubMessage, ILogger log)
        {
            log.LogInformation($"C# Event Hub trigger function processed a message: {myEventHubMessage}");
        }
    }
}

Recibo el siguiente error al depurar mi función de Azure con las herramientas de función de Azure para VS2017:

A ScriptHost error has occurred
Microsoft.Azure.WebJobs.Host: Error indexing method ''Functions.EnrichTelemetryLocation''. 
Microsoft.Azure.WebJobs.Host: Cannot bind parameter ''log'' to type ILogger. 
Make sure the parameter Type is supported by the binding. 
If you''re using binding extensions (e.g. ServiceBus, Timers, etc.) make sure you''ve called the registration method for the extension(s) in your startup code (e.g. config.UseServiceBus(), config.UseTimers(), etc.).

Answer 3

Versión corta Use el Microsoft.Azure.WebJobs.Host.TraceWriter disponible en este paquete nuget .

Alternativamente, genere sus funciones como un proyecto web y puede depurar localmente. Puedes encontrar una muestra aquí .

Versión larga

Su problema aquí es que está utilizando el TraceWriter incorrecto.

Utilicé el registrador de funciones de Azure en una función de Azure para generar el tipo de registrador.

log.Info(log.GetType().ToString());

Lo que dio lo siguiente:

Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter

Yo también esperaba un Web / Http TraceWriter y me sorprendió que haya otra implementación con la que lidiar. Microsoft realmente podría hacerlo con la creación de un enfoque estándar, o al menos darnos una interfaz limpia y agradable para Error, Advertencia, Información, Verbose, etc. Tal vez algo para .Net Standard ... por favor.

Crearé mi propia interfaz y envolveré el registrador de mi aplicación y el de Azure para que pueda inyectar lo que necesite sin causar dolores de cabeza en mi código. Esto también ofrecerá cierta protección contra el dolor potencial infligido por futuros cambios de ruptura.

De todos modos, estoy divagando, luego rastreé Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter hasta las funciones de Azure / Webjobs que ejecutan el repositorio de GitHub y luego en el paquete Nuget. He probado esto y funciona bien para pasar el registrador de funciones de Azure a su ensamblaje externo y continuar iniciando sesión en el entorno de funciones de Azure desde allí.

Aquí hay un ejemplo:

using Microsoft.Azure.WebJobs.Host;

public static void TryLog(TraceWriter azureFunctionsLogger)
{
    azureFunctionsLogger.Info("************** IT WORKED **************");
}

Me encanta el potencial de las funciones de Azure, pero aún es un poco inmaduro y demasiado complejo.

Espero que esto ayude.

Se agregó un registrador de clase única muy simple para ilustrar.

Escribe en el registrador de funciones de Azure o en un sistema estándar. Seguimiento de datos. Debe pegar esto sobre el contenido de Program.cs de una aplicación de consola C # estándar. También deberá incluir el paquete Nuget Microsoft.Azure.WebJobs .

namespace LoggingTestConsole
{
    using System;

    /// <summary>
    /// Generic logging interface for portability 
    /// </summary>
    public interface ILogger
    {
        void Error(string message);
        void Information(string message);
        void Warning(string message);
    }


    /// <summary>
    /// Azure Functions logger
    /// </summary>
    public class AzureFunctionLogger : ILogger
    {
        private static Microsoft.Azure.WebJobs.Host.TraceWriter _logger;

        public AzureFunctionLogger(Microsoft.Azure.WebJobs.Host.TraceWriter logger)
        {
            _logger = logger;
        }

        public void Error(string message)
        {
            _logger.Error(message);
        }

        public void Information(string message)
        {
            _logger.Info(message);
        }

        public void Warning(string message)
        {
            _logger.Warning(message);
        }
    }


    /// <summary>
    /// Windows Trace logger
    /// </summary>
    public class TraceLogger : ILogger
    {
        public TraceLogger()
        {
            System.Diagnostics.Trace.Listeners.Add(new System.Diagnostics.TextWriterTraceListener(Console.Out));
        }

        public void Error(string message)
        {
            System.Diagnostics.Trace.TraceError(message);
        }


        public void Information(string message)
        {
            System.Diagnostics.Trace.TraceInformation(message);
        }

        public void Warning(string message)
        {
            System.Diagnostics.Trace.TraceWarning(message);
        }

        public void Warning(string format, params object[] args)
        {
            System.Diagnostics.Trace.TraceWarning(format, args);
        }
    }

    /// <summary>
    /// You would put this in a separate project and just share the ILogger interface.
    /// Pass the relevant logger in from Azure Functions or a standard windows Trace logger.
    /// </summary>
    public class DoStuff
    {
        public DoStuff(ILogger logger)
        {
            logger.Information("We are logging to logger you passed in!");
        }
    }

    public class Program
    {

        /// <summary>
        /// Sample usage
        /// </summary>
        static void Main(string[] args)
        {
            // var loggerEnvironment = "AzureFunctions";
            var loggerEnvironment = "ConsoleApp";

            ILogger logger = null;

            if (loggerEnvironment == "AzureFunctions")
            {
                Microsoft.Azure.WebJobs.Host.TraceWriter azureFunctionLogger = null;
                logger = new AzureFunctionLogger(azureFunctionLogger);
            }
            else if (loggerEnvironment == "ConsoleApp")
            {
                logger = new TraceLogger();
            }

            var doStuff = new DoStuff(logger);
            Console.ReadKey();
        }
    }
}