Journalisation de la fonction Azure à L'aide D'un TraceWriter dans une bibliothèque externe

version courte Utilisez le Microsoft.Azure.WebJobs.Hôte.TraceWriter disponible en ce package nuget.

alternativement, construisez vos fonctions comme un 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é le logger de la fonction Azure dans une fonction Azure pour afficher le type de l'enregistreur.

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

Qui a donné l'exemple suivant:

Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter

moi aussi je m'attendais à un TraceWriter Web/Http 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 interface propre nice pour L'Erreur, Avertissement, Info, Verbose etc. Peut-être quelque chose pour la norme.Net... s'il vous plaît.

je vais créer ma propre interface et envelopper mon app logger et L'Azure one de sorte 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.

de toute façon, je m'égare, j'ai ensuite suivi Microsoft.Azure.WebJobs.Script.InterceptingTraceWriter en bas de l' Azure Fonctions / Webjobs script dépôt GitHub puis le paquet Nuget. J'ai testé et ça marche bien pour passer le La fonction Azure se connecte à votre assemblage externe et continue de se connecter à L'environnement de la fonction Azure à 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 d'Azur fonctions, mais il est encore un peu immature et trop complexe.

j'espère que cette aide.

ajout d'un logger de classe simple très simple pour illustrer.

il écrit à L'Enregistreur des fonctions Azure ou à un standard Système.Diagnostic.Trace. Vous devez coller cela sur le contenu du programme.cs d'une norme d'Application Console C#. Vous devrez également inclure le paquet 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();
        }
    }
}