web-dev-qa-db-fra.com

Journalisation de la fonction Azure à l'aide de TraceWriter dans une bibliothèque externe

Comment puis-je réutiliser l'objet TraceWriter disponible dans une fonction Azure pour consigner des informations dans une bibliothèque référencée en externe? J'ai essayé de passer l'objet en utilisant le constructeur et en référençant la classe TraceWriter (web.http.tracing). Je n'ai pas eu de chance car les cours semblent différents.

c#loggingazure-webjobsazure-functions
26
Lance

Version courte Utilisez Microsoft.Azure.WebJobs.Host.TraceWriter disponible dans ce paquet de pépites .

Alternativement, créez vos fonctions en tant que projet Web et vous pouvez déboguer localement. Vous pouvez trouver un exemple ici .

Version longue

Votre problème ici est que vous utilisez le mauvais TraceWriter.

J'ai utilisé l'enregistreur de fonction Azure dans une fonction Azure pour générer le type de l'enregistreur.

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

Ce qui a donné ce qui suit:

Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter

J'attendais moi aussi un Web/Http TraceWriter et j'ai été surpris qu'il y ait encore une autre implémentation à gérer. Microsoft pourrait vraiment faire avec la création d'une approche standard, ou au moins nous donner une belle interface propre pour Error, Warning, Info, Verbose etc. Peut-être quelque chose pour .Net Standard ... s'il vous plaît.

Je vais créer ma propre interface et encapsuler mon enregistreur d'applications et Azure afin que je puisse injecter ce dont j'ai besoin sans causer de maux de tête plus loin dans mon code. Cela offrira également une certaine protection contre la douleur potentielle infligée par les changements de rupture futurs.

Quoi qu'il en soit, je m'éloigne du sujet, j'ai ensuite suivi Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter jusqu'au Repo GitHub de scripts Azure Functions/Webjobs puis dans le package Nuget. J'ai testé cela et cela fonctionne très bien pour transmettre l'enregistreur Azure Function à votre assembly externe et continuer à vous connecter à l'environnement Azure Function à partir de là.

Voici un exemple:

using Microsoft.Azure.WebJobs.Host;

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

J'adore le potentiel des fonctions Azure, mais il est toujours un peu immature et trop complexe.

J'espère que ça aide.

Ajout d'un enregistreur simple classe très simple pour illustrer.

Il écrit soit dans Azure Functions Logger soit dans un Systems.Diagnostics.Trace standard. Vous devez coller cela sur le contenu de Program.cs d'une application console C # standard. Vous devrez également inclure le package 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();
        }
    }
}
39
Murray Foxcroft

En tant que mise à jour, Azure Functions prend désormais en charge la consommation d'un ILogger au lieu de TraceWritter afin que vous puissiez utiliser n'importe quelle infrastructure de journalisation qui implémente ILogger.

Voir le problème GitHub et le suivant documentation wiki .

9
Chris

Si je suis correct, les versions nécessaires pour que ILogger fonctionne avec les fonctions Azure seraient Microsoft.Azure.WebJobs 2.1.0-beta1. Cependant, je n'arrive pas à faire fonctionner une fonction Azure à l'aide d'un ILogger au lieu d'un TraceWriter.

De plus, très peu d'informations et de documentation sont disponibles sur le développement de fonctions Azure à l'aide d'ILogger. Quelqu'un a-t-il plus d'informations ou de conseils pour que cela fonctionne?

Mon extrait de code 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}");
        }
    }
}

J'obtiens l'erreur suivante lors du débogage de ma fonction Azure à l'aide des outils de fonction Azure pour 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.).
5
Boxed