Az Azure Functions monitorozásaMonitor Azure Functions

A Azure functions az Azure Application Insights beépített integrációját kínálja a függvények figyelésére.Azure Functions offers built-in integration with Azure Application Insights to monitor functions. Ez a cikk bemutatja, hogyan konfigurálhatja a Azure Functions a rendszer által létrehozott naplófájlok Application Insightsba való küldéséhez.This article shows you how to configure Azure Functions to send system-generated log files to Application Insights.

Javasoljuk, hogy használja a Application Insights, mert a napló-, a teljesítmény-és a hiba-adatokat gyűjti.We recommend using Application Insights because it collects log, performance, and error data. A szolgáltatás automatikusan észleli a teljesítménnyel kapcsolatos rendellenességeket, és hatékony elemzési eszközöket tartalmaz, amelyek segítenek a problémák diagnosztizálásában és a függvények használatának megismerésében.It automatically detects performance anomalies and includes powerful analytics tools to help you diagnose issues and to understand how your functions are used. Úgy tervezték, hogy használatával folyamatosan javíthassa a teljesítményt és a használhatóságot.It's designed to help you continuously improve performance and usability. Application Insights is használhatja a helyi funkció alkalmazás-projekt fejlesztése során.You can even use Application Insights during local function app project development. További információ: Mi az Application Insights?For more information, see What is Application Insights?.

Mivel a szükséges Application Insights rendszerállapot-Azure Functions be van építve, mindössze egy érvényes kialakítási kulcs szükséges ahhoz, hogy a Function alkalmazást egy Application Insights erőforráshoz lehessen kapcsolni.As the required Application Insights instrumentation is built into Azure Functions, all you need is a valid instrumentation key to connect your function app to an Application Insights resource.

Díjszabás és korlátozások Application InsightsApplication Insights pricing and limits

Kipróbálhatja Application Insights integrációját a Function apps ingyenes használatával.You can try out Application Insights integration with Function Apps for free. Napi korláttal rendelkezhet, hogy mennyi mennyiségű adatfeldolgozásra van lehetőség ingyenesen.There's a daily limit to how much data can be processed for free. Ezt a korlátot a tesztelés során is elérheti.You might hit this limit during testing. Az Azure portál-és e-mail-értesítéseket biztosít, ha közeledik a napi korláthoz.Azure provides portal and email notifications when you're approaching your daily limit. Ha kihagyja ezeket a riasztásokat, és lenyomja a korlátot, az új naplók nem jelennek meg Application Insights lekérdezésekben.If you miss those alerts and hit the limit, new logs won't appear in Application Insights queries. Ügyeljen arra, hogy a szükségtelen hibaelhárítási idő elkerülhető legyen.Be aware of the limit to avoid unnecessary troubleshooting time. További információ: a díjszabás és az adatmennyiség kezelése Application Insightsban.For more information, see Manage pricing and data volume in Application Insights.

A Function app számára elérhető Application Insights szolgáltatások teljes listáját a Azure functions által támogatott funkciók Application Insightsjábanrészletesen ismertetjük.The full list of Application Insights features available to your function app is detailed in Application Insights for Azure Functions supported features.

Application Insights integráció engedélyezéseEnable Application Insights integration

Ahhoz, hogy egy Function alkalmazás adatküldést Application Insights, ismernie kell egy Application Insights erőforrás rendszerállapot-kulcsát.For a function app to send data to Application Insights, it needs to know the instrumentation key of an Application Insights resource. A kulcsnak egy APPINSIGHTS_INSTRUMENTATIONKEYnevű alkalmazás-beállításban kell lennie.The key must be in an app setting named APPINSIGHTS_INSTRUMENTATIONKEY.

Új Function-alkalmazás a portálonNew function app in the portal

Ha a Azure Portal létrehozza a Function alkalmazást, Application Insights integráció alapértelmezés szerint engedélyezve van.When you create your function app in the Azure portal, Application Insights integration is enabled by default. A Application Insights erőforrás neve megegyezik a Function alkalmazás nevével, és az ugyanabban a régióban vagy a legközelebbi régióban jön létre.The Application Insights resource has the same name as your function app, and it's created either in the same region or in nearest region.

A létrehozandó Application Insights-erőforrás áttekintéséhez válassza ki azt a Application Insights ablak kibontásához.To review the Application Insights resource being created, select it to expand the Application Insights window. Módosíthatja az új erőforrás nevét , vagy kiválaszthat egy másik helyet az Azure-földrajzban , ahol az adatait tárolni szeretné.You can change the New resource name or choose a different Location in an Azure geography where you want to store your data.

Application Insights engedélyezése a Function app létrehozásakor

Ha a Létrehozáslehetőséget választja, a rendszer létrehoz egy Application Insights erőforrást a Function alkalmazással, amely az alkalmazás beállításai között szerepel a APPINSIGHTS_INSTRUMENTATIONKEY beállítással.When you choose Create, an Application Insights resource is created with your function app, which has the APPINSIGHTS_INSTRUMENTATIONKEY set in application settings. Minden készen áll.Everything is ready to go.

Hozzáadás meglévő Function-alkalmazáshozAdd to an existing function app

Amikor az Azure CLI, a Visual Studiovagy a Visual Studio Codehasználatával hoz létre egy Function alkalmazást, létre kell hoznia a Application Insights erőforrást.When you create a function app using the Azure CLI, Visual Studio, or Visual Studio Code, you must create the Application Insights resource. Ezután hozzáadhatja a kialakítási kulcsot az adott erőforrásból a Function alkalmazásban.You can then add the instrumentation key from that resource as an application setting in your function app.

A függvények megkönnyítik Application Insights integráció hozzáadását egy Function-alkalmazáshoz a Azure Portal.Functions makes it easy to add Application Insights integration to a function app from the Azure portal.

  1. A portálválassza a minden szolgáltatás > Function appslehetőséget, válassza ki a Function alkalmazást, majd válassza az ablak tetején található Application Insights szalagcímet.In the portal, select All services > Function Apps, select your function app, and then select the Application Insights banner at the top of the window

    Application Insights engedélyezése a portálról

  2. Hozzon létre egy Application Insights erőforrást a rendszerkép alatti táblázatban megadott beállítások használatával.Create an Application Insights resource by using the settings specified in the table below the image.

    Application Insights-erőforrás létrehozása

    BeállításSetting Ajánlott értékSuggested value LeírásDescription
    NameName Egyedi alkalmazás neveUnique app name A legegyszerűbb, ha ugyanazt a nevet használja, mint a Function alkalmazás, amelynek egyedinek kell lennie az előfizetésében.It's easiest to use the same name as your function app, which must be unique in your subscription.
    LocationLocation Nyugat-EurópaWest Europe Ha lehetséges, használja ugyanazt a régiót , mint a Function alkalmazás, vagy pedig az adott régióhoz közeledik.If possible, use the same region as your function app, or one that's close to that region.
  3. Kattintson az OK gombra.Select OK. A Application Insights erőforrás ugyanabban az erőforráscsoportban és előfizetésben jön létre, mint a Function alkalmazás.The Application Insights resource is created in the same resource group and subscription as your function app. Az erőforrás létrehozása után zárjuk be a Application Insights ablakot.After the resource is created, close the Application Insights window.

  4. Lépjen vissza a Function alkalmazásba, válassza az Alkalmazásbeállításoklehetőséget, majd görgessen le az Alkalmazásbeállítások menüponthoz.Back in your function app, select Application settings, and then scroll down to Application settings. Ha megjelenik egy nevű APPINSIGHTS_INSTRUMENTATIONKEYbeállítás, Application Insights integráció engedélyezve van az Azure-ban futó Function-alkalmazáshoz.If you see a setting named APPINSIGHTS_INSTRUMENTATIONKEY, Application Insights integration is enabled for your function app running in Azure.

A függvények korábbi verziói beépített figyelést használnak, ami már nem ajánlott.Early versions of Functions used built-in monitoring, which is no longer recommended. Ha egy ilyen Function alkalmazáshoz Application Insights integrációt engedélyez, le kell tiltania a beépített naplózástis.When enabling Application Insights integration for such a function app, you must also disable built-in logging.

Telemetria megtekintése a figyelés laponView telemetry in Monitor tab

Ha engedélyezve van Application Insights integráció, megtekintheti a telemetria a figyelés lapon.With Application Insights integration enabled, you can view telemetry data in the Monitor tab.

  1. A Function app (függvény alkalmazása) lapon válasszon ki egy olyan függvényt, amely legalább egyszer fut Application Insights konfigurálása után.In the function app page, select a function that has run at least once after Application Insights was configured. Ezután válassza a figyelés fület.Then select the Monitor tab.

    Figyelő lap kiválasztása

  2. Válassza a rendszeres frissítés lehetőséget, amíg meg nem jelenik a függvény meghívások listája.Select Refresh periodically, until the list of function invocations appears.

    Akár öt percet is igénybe vehet, amíg a lista megjelenik, miközben a telemetria-ügyfél a kiszolgálónak továbbított adatforgalmat.It can take up to five minutes for the list to appear while the telemetry client batches data for transmission to the server. (A késleltetés nem vonatkozik a élő metrikastreamra.(The delay doesn't apply to the Live Metrics Stream. A szolgáltatás a lap betöltésekor csatlakozik a functions-gazdagéphez, így a naplók közvetlenül az oldalra kerülnek.)That service connects to the Functions host when you load the page, so logs are streamed directly to the page.)

    Meghívások listája

  3. Egy adott függvény naplóinak megtekintéséhez válassza ki az adott hívás dátum oszlopának hivatkozását.To see the logs for a particular function invocation, select the Date column link for that invocation.

    Meghívási részletek hivatkozása

    Az adott hívás naplózási kimenete új lapon jelenik meg.The logging output for that invocation appears in a new page.

    Meghívás részletei

Láthatja, hogy mindkét oldalon fut Application Insights hivatkozás az Application Insights Analytics-lekérdezésre, amely beolvassa az információt.You can see that both pages have a Run in Application Insights link to the Application Insights Analytics query that retrieves the data.

Futtatás Application Insights

A következő lekérdezés jelenik meg.The following query is displayed. Láthatja, hogy a Meghívási lista az elmúlt 30 napra korlátozódik.You can see that the invocation list is limited to the last 30 days. A lista legfeljebb 20 sort mutat be (where timestamp > ago(30d) | take 20).The list shows no more than 20 rows (where timestamp > ago(30d) | take 20). A Meghívási részletek listája az elmúlt 30 napra korlátozza a korlátot.The invocation details list is for the last 30 days with no limit.

Application Insights Analytics-meghívások listája

További információ: telemetria- adatok lekérdezése a cikk későbbi részében.For more information, see Query telemetry data later in this article.

Telemetria megtekintése Application InsightsView telemetry in Application Insights

Ha Application Insights szeretne megnyitni a Azure Portalban lévő Function alkalmazásból, lépjen a Function alkalmazás Áttekintés lapjára.To open Application Insights from a function app in the Azure portal, go to the function app's Overview page. A konfigurált szolgáltatásokterületen válassza a Application Insightslehetőséget.Under Configured features, select Application Insights.

Application Insights megnyitása a Function app – áttekintés oldalon

A Application Insights használatáról az Application Insights dokumentációjábanolvashat bővebben.For information about how to use Application Insights, see the Application Insights documentation. Ez a szakasz néhány példát mutat be a Application Insights lévő adatmegjelenítésre.This section shows some examples of how to view data in Application Insights. Ha már ismeri a Application Insightst, közvetlenül a telemetria-adatainak konfigurálásával és testreszabásával foglalkozó fejezetekreléphet.If you're already familiar with Application Insights, you can go directly to the sections about how to configure and customize the telemetry data.

Application Insights Áttekintés lap

Az Application Insights következő területei hasznosak lehetnek a függvények viselkedésének, teljesítményének és hibáinak kiértékelése során:The following areas of Application Insights can be helpful when evaluating the behavior, performance, and errors in your functions:

LaponTab LeírásDescription
HibákFailures Diagramok és riasztások létrehozása a függvények hibái és a kiszolgálói kivételek alapján.Create charts and alerts based on function failures and server exceptions. A művelet neve a függvény neve.The Operation Name is the function name. A függőségek meghibásodása csak akkor jelenik meg, ha egyéni telemetria valósít meg a függőségekhez.Failures in dependencies aren't shown unless you implement custom telemetry for dependencies.
TeljesítményPerformance Teljesítménnyel kapcsolatos problémák elemzése.Analyze performance issues.
KiszolgálókServers Megtekintheti a kiszolgálón az erőforrás-kihasználtságot és az átviteli sebességet.View resource utilization and throughput per server. Ez az adat hasznos lehet olyan forgatókönyvek hibakereséséhez, ahol a függvények a mögöttes erőforrások leállását végzik.This data can be useful for debugging scenarios where functions are bogging down your underlying resources. A kiszolgálókat Felhőbeli szerepkör-példányoknaknevezzük.Servers are referred to as Cloud role instances.
MutatókatMetrics Metrikák alapján létrehozhat diagramokat és riasztásokat.Create charts and alerts that are based on metrics. A metrikák közé tartozik a Function meghívások száma, a végrehajtási idő és a sikerességi arány.Metrics include the number of function invocations, execution time, and success rates.
Élő metrikastreamLive Metrics Stream A metrikák adatait tekintheti meg valós időben létrehozva.View metrics data as it's created in real time.

Telemetria-adatbázis lekérdezéseQuery telemetry data

Application Insights Analytics hozzáférést biztosít minden telemetria-adatbázishoz egy adatbázisban lévő táblák formájában.Application Insights Analytics gives you access to all telemetry data in the form of tables in a database. Az elemzés lekérdezési nyelvet biztosít az adatok kinyeréséhez, módosításához és megjelenítéséhez.Analytics provides a query language for extracting, manipulating, and visualizing the data.

Elemzés kiválasztása

Elemzési példa

Az alábbi példa egy lekérdezési példát mutat be, amely az elmúlt 30 percben megjeleníti az egyes feldolgozó kérelmek eloszlását.Here's a query example that shows the distribution of requests per worker over the last 30 minutes.

requests
| where timestamp > ago(30m) 
| summarize count() by cloud_RoleInstance, bin(timestamp, 1m)
| render timechart

A rendelkezésre álló táblák a bal oldali séma lapon jelennek meg.The tables that are available are shown in the Schema tab on the left. Az alábbi táblázatokban megtalálhatja a függvények által generált adathívásokat:You can find data generated by function invocations in the following tables:

TableTable LeírásDescription
nyomoktraces A futtatókörnyezet és a függvény kódja által létrehozott naplók.Logs created by the runtime and by function code.
kérelmekrequests Egy kérelem az egyes függvények meghívásához.One request for each function invocation.
kivételekexceptions A futtatókörnyezet által kiváltott kivételek.Any exceptions thrown by the runtime.
customMetricscustomMetrics A sikeres és sikertelen meghívások száma, a sikerességi arány és az időtartam.The count of successful and failing invocations, success rate, and duration.
customEventscustomEvents A futtatókörnyezet által követett események, például: a függvényt kiváltó HTTP-kérelmek.Events tracked by the runtime, for example: HTTP requests that trigger a function.
performanceCountersperformanceCounters Információk azon kiszolgálók teljesítményéről, amelyeken a függvények futnak.Information about the performance of the servers that the functions are running on.

A többi tábla a rendelkezésre állási tesztekhez, valamint az ügyfél és a böngésző telemetria.The other tables are for availability tests, and client and browser telemetry. Egyéni telemetria is létrehozhat, amelyekkel adathozzáadást adhat hozzájuk.You can implement custom telemetry to add data to them.

Az egyes függvényekre jellemző adatok egy customDimensions mezőben találhatók.Within each table, some of the Functions-specific data is in a customDimensions field. A következő lekérdezés például lekéri az összes olyan nyomkövetést, amelynek a naplózási szintje Error.For example, the following query retrieves all traces that have log level Error.

traces 
| where customDimensions.LogLevel == "Error"

A futtatókörnyezet biztosítja a customDimensions.LogLevel és customDimensions.Category mezőket.The runtime provides the customDimensions.LogLevel and customDimensions.Category fields. További mezőket is megadhat a függvény kódjába írt naplókban.You can provide additional fields in logs that you write in your function code. Lásd a jelen cikk későbbi, strukturált naplózás című részében.See Structured logging later in this article.

Kategóriák és naplózási szintek konfigurálásaConfigure categories and log levels

A Application Insightst egyéni konfiguráció nélkül is használhatja.You can use Application Insights without any custom configuration. Az alapértelmezett konfiguráció nagy mennyiségű adattal járhat.The default configuration can result in high volumes of data. Ha Visual Studio Azure-előfizetést használ, előfordulhat, hogy a Application Insightshoz tartozó adatkorlátot is elérheti.If you're using a Visual Studio Azure subscription, you might hit your data cap for Application Insights. A cikk későbbi részében megtudhatja, hogyan konfigurálhatja és testre szabhatja a függvények által Application Insightsba küldött adatok konfigurálását.Later in this article, you learn how to configure and customize the data that your functions send to Application Insights. Egy Function alkalmazás esetében a naplózás a Host. JSON fájlban van konfigurálva.For a function app, logging is configured in the host.json file.

KategóriákCategories

A Azure Functions Logger minden naplóhoz tartalmaz kategóriát .The Azure Functions logger includes a category for every log. A kategória azt jelzi, hogy a futásidejű kód mely része vagy a függvény kódja írta a naplót.The category indicates which part of the runtime code or your function code wrote the log.

A functions futtatókörnyezet olyan naplókat hoz létre, amelyek a "host" kezdetű kategóriába tartoznak.The Functions runtime creates logs with a category that begin with "Host." Az 1. x verzióban a function started, function executed és function completed naplók Host.Executor kategóriába tartoznak.In version 1.x, the function started, function executed, and function completed logs have the category Host.Executor. A 2. x verziótól kezdődően ezek a naplók a következő kategóriába tartoznak: Function.<YOUR_FUNCTION_NAME>.Starting in version 2.x, these logs have the category Function.<YOUR_FUNCTION_NAME>.

Ha naplókat ír a függvény kódjába, a kategória a functions futtatókörnyezet 1. x verziójában Function.If you write logs in your function code, the category is Function in version 1.x of the Functions runtime. A 2. x verzióban a kategória Function.<YOUR_FUNCTION_NAME>.User.In version 2.x, the category is Function.<YOUR_FUNCTION_NAME>.User.

Naplózási szintekLog levels

A Azure Functions naplózó naplózási szintet is tartalmaz minden naplóval.The Azure Functions logger also includes a log level with every log. A naplózási szint egy enumerálás, és az egész szám kód relatív fontosságot jelez:LogLevel is an enumeration, and the integer code indicates relative importance:

Naplózási szintLogLevel KódCode
NyomkövetésTrace 00
HibakeresésDebug 11
InformációInformation 22
FigyelmeztetésWarning 33
HibaError 44
KritikusCritical 55
NoneNone 66

A következő szakaszban ismertetett naplózási szintű @no__t – 0.Log level None is explained in the next section.

Konfiguráció naplózása a Host. JSON fájlbanLog configuration in host.json

A Host. JSON fájl azt konfigurálja, hogy a Function app hogyan küldi el a Application Insights.The host.json file configures how much logging a function app sends to Application Insights. Minden kategória esetében meg kell határozni a küldéshez minimálisan szükséges naplózási szintet.For each category, you indicate the minimum log level to send. Két példa létezik: az első példa a functions 2. x verziójának (.net Core) verzióját célozza meg, a második példa pedig az 1. x futtatókörnyezet.There are two examples: the first example targets the Functions version 2.x runtime (.NET Core) and the second example is for the version 1.x runtime.

2-es verzió. xVersion 2.x

A v2. x futtatókörnyezet a .net Core naplózási szűrő hierarchiájáthasználja.The v2.x runtime uses the .NET Core logging filter hierarchy.

{
  "logging": {
    "fileLoggingMode": "always",
    "logLevel": {
      "default": "Information",
      "Host.Results": "Error",
      "Function": "Error",
      "Host.Aggregator": "Trace"
    }
  }
}

1. x verzióVersion 1.x

{
  "logger": {
    "categoryFilter": {
      "defaultLevel": "Information",
      "categoryLevels": {
        "Host.Results": "Error",
        "Function": "Error",
        "Host.Aggregator": "Trace"
      }
    }
  }
}

Ez a példa a következő szabályokat állítja be:This example sets up the following rules:

  • A Host.Results vagy Function kategóriába tartozó naplók esetében a csak a Error szintet és a Application Insightst kell elküldeni.For logs with category Host.Results or Function, send only Error level and above to Application Insights. A Warning szint és az alábbi naplók figyelmen kívül lesznek hagyva.Logs for Warning level and below are ignored.
  • A Host.Aggregator kategóriába tartozó naplók esetében az összes naplót küldje el Application Insights.For logs with category Host.Aggregator, send all logs to Application Insights. A Trace naplózási szint ugyanaz, mint amit néhány adatgyűjtő hív Verbose, de a Host. JSON fájlban használja a Trace értéket.The Trace log level is the same as what some loggers call Verbose, but use Trace in the host.json file.
  • Az összes többi napló esetében csak a Information szint és a felett kell elküldeni a Application Insights.For all other logs, send only Information level and above to Application Insights.

A Host. JSON kategória értéke az összes olyan kategória naplózását szabályozza, amely azonos értékkel kezdődik.The category value in host.json controls logging for all categories that begin with the same value. Host a Host. JSON vezérlőkben Host.General, Host.Executor, Host.Results stb. naplózása.Host in host.json controls logging for Host.General, Host.Executor, Host.Results, and so on.

Ha a Host. JSON több olyan kategóriát tartalmaz, amelyek ugyanazzal a karakterlánccal kezdődnek, akkor a többit is megegyeznek.If host.json includes multiple categories that start with the same string, the longer ones are matched first. Tegyük fel, hogy a futtatókörnyezetből mindent szeretne, kivéve a Host.Aggregator értéket Error szinten való bejelentkezéshez, de a Host.Aggregator parancsot szeretné használni a @no__t – 3 szinten:Suppose you want everything from the runtime except Host.Aggregator to log at Error level, but you want Host.Aggregator to log at the Information level:

2-es verzió. xVersion 2.x

{
  "logging": {
    "fileLoggingMode": "always",
    "logLevel": {
      "default": "Information",
      "Host": "Error",
      "Function": "Error",
      "Host.Aggregator": "Information"
    }
  }
}

1. x verzióVersion 1.x

{
  "logger": {
    "categoryFilter": {
      "defaultLevel": "Information",
      "categoryLevels": {
        "Host": "Error",
        "Function": "Error",
        "Host.Aggregator": "Information"
      }
    }
  }
}

Egy kategória összes naplójának letiltásához használhatja a None naplózási szintet.To suppress all logs for a category, you can use log level None. A rendszer nem ír naplókat az adott kategóriával, és nincs felettük naplózási szint.No logs are written with that category and there's no log level above it.

A következő szakaszok a futtatókörnyezet által létrehozott naplók fő kategóriáit ismertetik.The following sections describe the main categories of logs that the runtime creates.

Kategória Host. ResultsCategory Host.Results

Ezek a naplók Application Insights kérelmekként jelennek meg.These logs show as "requests" in Application Insights. A függvények sikerességét vagy hibáját jelzik.They indicate success or failure of a function.

Kérelmek diagramja

Az összes napló Information szinten van írva.All of these logs are written at Information level. Ha Warning vagy újabb értékre szűr, nem fogja látni ezeket az adatmennyiséget.If you filter at Warning or above, you won't see any of this data.

Kategória Host. aggregatorCategory Host.Aggregator

Ezek a naplók a függvények számát és átlagát biztosítják egy konfigurálható időszakra vonatkozóan.These logs provide counts and averages of function invocations over a configurable period of time. Az alapértelmezett időtartam 30 másodperc vagy 1 000 eredmény, attól függően, hogy melyik következik be először.The default period is 30 seconds or 1,000 results, whichever comes first.

A naplók a Application Insights customMetrics táblájában érhetők el.The logs are available in the customMetrics table in Application Insights. Ilyenek például a futtatások száma, a sikerességi arány és az időtartam.Examples are the number of runs, success rate, and duration.

customMetrics-lekérdezés

Az összes napló Information szinten van írva.All of these logs are written at Information level. Ha Warning vagy újabb értékre szűr, nem fogja látni ezeket az adatmennyiséget.If you filter at Warning or above, you won't see any of this data.

Egyéb kategóriákOther categories

A már felsorolt kategóriákhoz tartozó összes napló a Application Insights nyomkövetési táblájában érhető el.All logs for categories other than the ones already listed are available in the traces table in Application Insights.

nyomkövetési lekérdezés

Az Host kezdetű kategóriákat tartalmazó naplókat a functions futtatókörnyezet írja.All logs with categories that begin with Host are written by the Functions runtime. A "függvény elindítva" és a "Function Completed" naplók kategóriája Host.Executor.The "Function started" and "Function completed" logs have category Host.Executor. A sikeres futtatáshoz ezek a naplók Information szinten vannak.For successful runs, these logs are Information level. A kivételek naplózása Error szinten történik.Exceptions are logged at Error level. A futtatókörnyezet @no__t – 0 szintű naplókat is létrehoz, például: üzenetsor-üzenetek küldését a méreg várólistába.The runtime also creates Warning level logs, for example: queue messages sent to the poison queue.

A függvény kódjában írt naplóknak van Function kategóriája, és bármilyen naplózási szint lehet.Logs written by your function code have category Function and can be any log level.

A gyűjtő konfigurálásaConfigure the aggregator

Ahogy az előző szakaszban is látható, a futtatókörnyezet összesíti a függvények végrehajtásával kapcsolatos adatokat egy adott időszakban.As noted in the previous section, the runtime aggregates data about function executions over a period of time. Az alapértelmezett időtartam 30 másodperc vagy 1 000 fut, amelyik előbb eléri a értéket.The default period is 30 seconds or 1,000 runs, whichever comes first. Ezt a beállítást a Host. JSON fájlban állíthatja be.You can configure this setting in the host.json file. Például:Here's an example:

{
    "aggregator": {
      "batchSize": 1000,
      "flushTimeout": "00:00:30"
    }
}

Mintavételezés konfigurálásaConfigure sampling

Application Insights tartalmaz egy mintavételi funkciót, amely képes arra, hogy túl sok telemetria-adatmennyiséget állítson elő a befejezett végrehajtásokon a maximális terhelés idején.Application Insights has a sampling feature that can protect you from producing too much telemetry data on completed executions at times of peak load. Ha a bejövő végrehajtások aránya meghaladja a megadott küszöbértéket, Application Insights véletlenszerűen figyelmen kívül hagyja a bejövő végrehajtások némelyikét.When the rate of incoming executions exceeds a specified threshold, Application Insights starts to randomly ignore some of the incoming executions. A másodpercenkénti végrehajtások maximális számának alapértelmezett beállítása 20 (öt az 1. x verzióban).The default setting for maximum number of executions per second is 20 (five in version 1.x). A mintavételt a Host. JSONfájlban állíthatja be.You can configure sampling in host.json. Például:Here's an example:

2-es verzió. xVersion 2.x

{
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "maxTelemetryItemsPerSecond" : 20
      }
    }
  }
}

1. x verzióVersion 1.x

{
  "applicationInsights": {
    "sampling": {
      "isEnabled": true,
      "maxTelemetryItemsPerSecond" : 5
    }
  }
}

Megjegyzés

A mintavétel alapértelmezés szerint engedélyezve van.Sampling is enabled by default. Ha úgy tűnik, hogy hiányoznak az adatok, előfordulhat, hogy módosítania kell a mintavételi beállításokat, hogy az megfeleljen az adott figyelési forgatókönyvnek.If you appear to be missing data, you might need to adjust the sampling settings to fit your particular monitoring scenario.

Naplók írása a C# functions szolgáltatásbanWrite logs in C# functions

A függvény kódjában olyan naplókat írhat, amelyek nyomkövetésként jelennek meg Application Insightsban.You can write logs in your function code that appear as traces in Application Insights.

ILoggerILogger

@No__t-1 paraméter helyett használja a függvények ILogger paraméterét.Use an ILogger parameter in your functions instead of a TraceWriter parameter. A TraceWriter Application Insights használatával létrehozott naplók, de a ILogger lehetővé teszi a strukturált naplózást.Logs created by using TraceWriter go to Application Insights, but ILogger lets you do structured logging.

@No__t-0 objektummal a naplók létrehozásához a ILogger Log<level> bővítményi metódusát kell meghívni.With an ILogger object, you call Log<level> extension methods on ILogger to create logs. A következő kód a "Function" kategóriába tartozó Information naplókat írja le.The following code writes Information logs with category "Function."

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger logger)
{
    logger.LogInformation("Request for item with key={itemKey}.", id);

Strukturált naplózásStructured logging

A helyőrzők sorrendje, a nevük nem, meghatározza, hogy a rendszer mely paramétereket használja a naplófájlban.The order of placeholders, not their names, determines which parameters are used in the log message. Tegyük fel, hogy a következő kóddal rendelkezik:Suppose you have the following code:

string partitionKey = "partitionKey";
string rowKey = "rowKey";
logger.LogInformation("partitionKey={partitionKey}, rowKey={rowKey}", partitionKey, rowKey);

Ha megtartja ugyanazt az üzenetet, és megfordítja a paraméterek sorrendjét, az eredményül kapott üzenet szövege nem megfelelő helyen lenne.If you keep the same message string and reverse the order of the parameters, the resulting message text would have the values in the wrong places.

A helyőrzők kezelése így történik, így strukturált naplózást végezhet.Placeholders are handled this way so that you can do structured logging. Application Insights a paraméter név-érték párokat és az üzenet karakterláncát tárolja.Application Insights stores the parameter name-value pairs and the message string. Ennek az az oka, hogy az üzenet argumentumai olyan mezők lesznek, amelyeken lekérdezéseket végezhet.The result is that the message arguments become fields that you can query on.

Ha a naplózó metódus hívása az előző példához hasonlóan néz ki, akkor customDimensions.prop__rowKey mezőt kérdezheti le.If your logger method call looks like the previous example, you can query the field customDimensions.prop__rowKey. A prop__ előtag hozzá lett adva, így biztosítva, hogy nincsenek ütközések a futtatókörnyezet által hozzáadott és mezőket tartalmazó mezők között.The prop__ prefix is added to ensure there are no collisions between fields the runtime adds and fields your function code adds.

Az eredeti üzenet sztringjét is lekérdezheti, ha a customDimensions.prop__{OriginalFormat} mezőre hivatkozik.You can also query on the original message string by referencing the field customDimensions.prop__{OriginalFormat}.

Itt látható a customDimensions típusú adat JSON-ábrázolása:Here's a sample JSON representation of customDimensions data:

{
  customDimensions: {
    "prop__{OriginalFormat}":"C# Queue trigger function processed: {message}",
    "Category":"Function",
    "LogLevel":"Information",
    "prop__message":"c9519cbf-b1e6-4b9b-bf24-cb7d10b1bb89"
  }
}

Egyéni metrikák naplózásaCustom metrics logging

A C# script functions szolgáltatásban a ILogger LogMetric kiterjesztési módszerével egyéni metrikákat hozhat létre Application Insights.In C# script functions, you can use the LogMetric extension method on ILogger to create custom metrics in Application Insights. Íme egy példa metódus hívása:Here's a sample method call:

logger.LogMetric("TestMetric", 1234);

Ez a kód a .NET-hez készült Application Insights API-val való TrackMetric meghívásának alternatívája.This code is an alternative to calling TrackMetric by using the Application Insights API for .NET.

Naplók írása JavaScript-függvényekbenWrite logs in JavaScript functions

A Node. js függvényeknél használja a context.log értéket a naplók írásához.In Node.js functions, use context.log to write logs. A strukturált naplózás nincs engedélyezve.Structured logging isn't enabled.

context.log('JavaScript HTTP trigger function processed a request.' + context.invocationId);

Egyéni metrikák naplózásaCustom metrics logging

Ha a functions futtatókörnyezet 1. x verziójában fut, a Node. js függvények a context.log.metric metódus használatával hozhatnak létre egyéni metrikákat a Application Insights.When you're running on version 1.x of the Functions runtime, Node.js functions can use the context.log.metric method to create custom metrics in Application Insights. Ez a metódus jelenleg nem támogatott a 2. x verzióban.This method isn't currently supported in version 2.x. Íme egy példa metódus hívása:Here's a sample method call:

context.log.metric("TestMetric", 1234);

Ez a kód a Application Insights Node. js SDK-val való meghívására szolgáló alternatíva trackMetric.This code is an alternative to calling trackMetric by using the Node.js SDK for Application Insights.

Egyéni telemetria naplózása C# a functions szolgáltatásbanLog custom telemetry in C# functions

A Microsoft. ApplicationInsights NuGet-csomag segítségével egyéni telemetria-fájlokat küldhet a Application Insightsba.You can use the Microsoft.ApplicationInsights NuGet package to send custom telemetry data to Application Insights. Az alábbi C# példa az Egyéni telemetria API-t használja.The following C# example uses the custom telemetry API. A példa egy .NET-osztályhoz tartozó könyvtárra mutat, de a Application Insights kódja megegyezik C# a parancsfájlhoz.The example is for a .NET class library, but the Application Insights code is the same for C# script.

2-es verzió. xVersion 2.x

A 2. x verziójú futtatókörnyezet a Application Insights újabb funkcióit használja, hogy automatikusan korrelálja a telemetria az aktuális művelettel.The version 2.x runtime uses newer features in Application Insights to automatically correlate telemetry with the current operation. Nem kell manuálisan beállítania a műveletet Id, ParentId vagy Name mezőt.There's no need to manually set the operation Id, ParentId, or Name fields.

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;

namespace functionapp0915
{
    public class HttpTrigger2
    {
        private readonly TelemetryClient telemetryClient;

        /// Using dependency injection will guarantee that you use the same configuration for telemetry collected automatically and manually.
        public HttpTrigger2(TelemetryConfiguration telemetryConfiguration)
        {
            this.telemetryClient = new TelemetryClient(telemetryConfiguration);
        }

        [FunctionName("HttpTrigger2")]
        public Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
            HttpRequest req, ExecutionContext context, ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            DateTime start = DateTime.UtcNow;

            // Parse query parameter
            string name = req.Query
                .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
                .Value;

            // Track an Event
            var evt = new EventTelemetry("Function called");
            evt.Context.User.Id = name;
            this.telemetryClient.TrackEvent(evt);

            // Track a Metric
            var metric = new MetricTelemetry("Test Metric", DateTime.Now.Millisecond);
            metric.Context.User.Id = name;
            this.telemetryClient.TrackMetric(metric);

            // Track a Dependency
            var dependency = new DependencyTelemetry
            {
                Name = "GET api/planets/1/",
                Target = "swapi.co",
                Data = "https://swapi.co/api/planets/1/",
                Timestamp = start,
                Duration = DateTime.UtcNow - start,
                Success = true
            };
            dependency.Context.User.Id = name;
            this.telemetryClient.TrackDependency(dependency);

            return Task.FromResult<IActionResult>(new OkResult());
        }
    }
}

1. x verzióVersion 1.x

using System;
using System.Net;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.Azure.WebJobs;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
using System.Linq;

namespace functionapp0915
{
    public static class HttpTrigger2
    {
        private static string key = TelemetryConfiguration.Active.InstrumentationKey = 
            System.Environment.GetEnvironmentVariable(
                "APPINSIGHTS_INSTRUMENTATIONKEY", EnvironmentVariableTarget.Process);

        private static TelemetryClient telemetryClient = 
            new TelemetryClient() { InstrumentationKey = key };

        [FunctionName("HttpTrigger2")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]
            HttpRequestMessage req, ExecutionContext context, ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            DateTime start = DateTime.UtcNow;

            // Parse query parameter
            string name = req.GetQueryNameValuePairs()
                .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
                .Value;

            // Get request body
            dynamic data = await req.Content.ReadAsAsync<object>();

            // Set name to query string or body data
            name = name ?? data?.name;
         
            // Track an Event
            var evt = new EventTelemetry("Function called");
            UpdateTelemetryContext(evt.Context, context, name);
            telemetryClient.TrackEvent(evt);
            
            // Track a Metric
            var metric = new MetricTelemetry("Test Metric", DateTime.Now.Millisecond);
            UpdateTelemetryContext(metric.Context, context, name);
            telemetryClient.TrackMetric(metric);
            
            // Track a Dependency
            var dependency = new DependencyTelemetry
                {
                    Name = "GET api/planets/1/",
                    Target = "swapi.co",
                    Data = "https://swapi.co/api/planets/1/",
                    Timestamp = start,
                    Duration = DateTime.UtcNow - start,
                    Success = true
                };
            UpdateTelemetryContext(dependency.Context, context, name);
            telemetryClient.TrackDependency(dependency);
        }
        
        // Correlate all telemetry with the current Function invocation
        private static void UpdateTelemetryContext(TelemetryContext context, ExecutionContext functionContext, string userName)
        {
            context.Operation.Id = functionContext.InvocationId.ToString();
            context.Operation.ParentId = functionContext.InvocationId.ToString();
            context.Operation.Name = functionContext.FunctionName;
            context.User.Id = userName;
        }
    }    
}

Ne hívja meg a TrackRequest vagy a StartOperation<RequestTelemetry> értéket, mert a függvény meghívásához ismétlődő kérelmeket fog látni.Don't call TrackRequest or StartOperation<RequestTelemetry> because you'll see duplicate requests for a function invocation. A függvények futtatókörnyezete automatikusan nyomon követi a kérelmeket.The Functions runtime automatically tracks requests.

Ne állítsa be a telemetryClient.Context.Operation.Id értéket.Don't set telemetryClient.Context.Operation.Id. Ez a globális beállítás helytelen korrelációt okoz, ha sok függvény egyidejűleg fut.This global setting causes incorrect correlation when many functions are running simultaneously. Ehelyett hozzon létre egy új telemetria-példányt (DependencyTelemetry, EventTelemetry), és módosítsa a Context tulajdonságát.Instead, create a new telemetry instance (DependencyTelemetry, EventTelemetry) and modify its Context property. Ezután adja át a telemetria-példányt a megfelelő Track metódusnak TelemetryClient (TrackDependency(), TrackEvent()) értékre.Then pass in the telemetry instance to the corresponding Track method on TelemetryClient (TrackDependency(), TrackEvent()). Ez a módszer biztosítja, hogy a telemetria megfelelő korrelációs adatokat biztosítson az aktuális függvény meghívásához.This method ensures that the telemetry has the correct correlation details for the current function invocation.

Egyéni telemetria naplózása a JavaScript-függvényekbenLog custom telemetry in JavaScript functions

Íme egy kódrészlet, amely egyéni telemetria küld az Application Insights Node. js SDK-val:Here is a sample code snippet that sends custom telemetry with the Application Insights Node.js SDK:

const appInsights = require("applicationinsights");
appInsights.setup();
const client = appInsights.defaultClient;

module.exports = function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    client.trackEvent({name: "my custom event", tagOverrides:{"ai.operation.id": context.invocationId}, properties: {customProperty2: "custom property value"}});
    client.trackException({exception: new Error("handled exceptions can be logged with this method"), tagOverrides:{"ai.operation.id": context.invocationId}});
    client.trackMetric({name: "custom metric", value: 3, tagOverrides:{"ai.operation.id": context.invocationId}});
    client.trackTrace({message: "trace message", tagOverrides:{"ai.operation.id": context.invocationId}});
    client.trackDependency({target:"http://dbname", name:"select customers proc", data:"SELECT * FROM Customers", duration:231, resultCode:0, success: true, dependencyTypeName: "ZSQL", tagOverrides:{"ai.operation.id": context.invocationId}});
    client.trackRequest({name:"GET /customers", url:"http://myserver/customers", duration:309, resultCode:200, success:true, tagOverrides:{"ai.operation.id": context.invocationId}});

    context.done();
};

A tagOverrides paraméter a operation_Id értéket állítja be a függvény Meghívási AZONOSÍTÓJÁHOZ.The tagOverrides parameter sets the operation_Id to the function's invocation ID. Ez a beállítás lehetővé teszi egy adott függvény összes automatikusan generált és egyéni telemetria korrelációját.This setting enables you to correlate all of the automatically generated and custom telemetry for a given function invocation.

FüggőségekDependencies

A functions v2 automatikusan összegyűjti a HTTP-kérelmekre, a ServiceBus és az SQL-re vonatkozó függőségeket.Functions v2 automatically collects dependencies for HTTP requests, ServiceBus, and SQL.

A függőségek megjelenítéséhez egyéni kódot is írhat.You can write custom code to show the dependencies. Példákért tekintse meg a mintakód szakaszt az C# egyéni telemetria szakaszban.For examples, see the sample code in the C# custom telemetry section. A mintakód olyan Application Insights alkalmazás- hozzárendelést eredményez, amely a következő képhez hasonlóan néz ki:The sample code results in an application map in Application Insights that looks like the following image:

Alkalmazástérkép

Problémák jelentéseReport issues

Ha Application Insights-integrációval kapcsolatos problémát szeretne jelenteni a functions szolgáltatásban, vagy javaslatot vagy kérést szeretne készíteni, hozzon létre egy problémát a githubban.To report an issue with Application Insights integration in Functions, or to make a suggestion or request, create an issue in GitHub.

Folyamatos átviteli naplókStreaming Logs

Egy alkalmazás fejlesztése során gyakran érdemes megtekinteni, hogy mi történik a naplókba közel valós időben, amikor az Azure-ban fut.While developing an application, you often want to see what's being written to the logs in near-real time when running in Azure.

Kétféle módon lehet megtekinteni a függvények végrehajtásával létrehozott naplófájlok streamjét.There are two ways to view a stream of log files being generated by your function executions.

  • Beépített log streaming: a app Service platformon megtekintheti az alkalmazás naplófájljainak streamjét.Built-in log streaming: the App Service platform lets you view a stream of your application log files. Ez egyenértékű azzal a kimenettel, amelyet a függvények a helyi fejlesztés során végzett hibakereséskor, illetve a portálon a teszt lap használatakor észlelt.This is equivalent to the output seen when you debug your functions during local development and when you use the Test tab in the portal. Megjelenik az összes napló alapú információ.All log-based information is displayed. További információ: stream- naplók.For more information, see Stream logs. Ez a folyamatos átviteli módszer csak egyetlen példányt támogat, és nem használható a Linux rendszeren futó alkalmazással egy használati tervben.This streaming method supports only a single instance, and can't be used with an app running on Linux in a Consumption plan.

  • Élő metrikastream: Ha a Function alkalmazás csatlakoztatva van a Application Insightshoz, akkor a Azure Portal a élő metrikastreamsegítségével közel valós időben megtekintheti a naplózási adatokat és az egyéb metrikákat.Live Metrics Stream: when your function app is connected to Application Insights, you can view log data and other metrics in near-real time in the Azure portal using Live Metrics Stream. Ezt a módszert akkor használja, ha több példányon vagy Linuxon futó figyelési funkciót használ a használati tervben.Use this method when monitoring functions running on multiple-instances or on Linux in a Consumption plan. Ez a metódus mintavételes adathalmazthasznál.This method uses sampled data.

A naplózási streamek a Portálon és a legtöbb helyi fejlesztési környezetben is megtekinthetők.Log streams can be viewed both in the portal and in most local development environments.

PortálPortal

A portálon mindkét típusú naplózási adatfolyamot megtekintheti.You can view both types of log streams in the portal.

Beépített log streamingBuilt-in log streaming

Ha a portálon szeretné megtekinteni a folyamatos átviteli naplókat, válassza a platform szolgáltatások fület a Function alkalmazásban.To view streaming logs in the portal, select the Platform features tab in your function app. Ezután a figyelésterületen válassza a naplózási adatfolyamlehetőséget.Then, under Monitoring, choose Log streaming.

Folyamatos átviteli naplók engedélyezése a portálon

Ezzel összekapcsolja az alkalmazást a log streaming szolgáltatáshoz, és az alkalmazás naplói megjelennek az ablakban.This connects your app to the log streaming service and application logs are displayed in the window. Válthat az alkalmazási naplók és a webkiszolgálói naplókközött.You can toggle between Application logs and Web server logs.

Folyamatos átviteli naplók megtekintése a portálon

Élő metrikastreamLive Metrics Stream

Az alkalmazás Élő metrikastream megtekintéséhez válassza a Function app Áttekintés lapját.To view the Live Metrics Stream for your app, select the Overview tab of your function app. Application Insights engedélyezése esetén a konfigurált szolgáltatásokterületen megjelenik egy Application Insights -hivatkozás.When you have Application Insights enables, you see an Application Insights link under Configured features. Ez a hivatkozás az alkalmazás Application Insights lapjára lép.This link takes you to the Application Insights page for your app.

A Application Insights területen válassza a élő metrikastreamlehetőséget.In Application Insights, select Live Metrics Stream. A mintavételes naplóbejegyzések a minta telemetriaalatt jelennek meg.Sampled log entries are displayed under Sample Telemetry.

Élő metrikastream megtekintése a portálon

Visual Studio-kódVisual Studio Code

Az Azure-beli Function alkalmazáshoz tartozó folyamatos átviteli naplók bekapcsolása:To turn on the streaming logs for your function app in Azure:

  1. Válassza az F1 billentyűt a parancs paletta megnyitásához, majd keresse meg és futtassa a parancsot Azure functions: Adatfolyam-naplókindítása.Select F1 to open the command palette, and then search for and run the command Azure Functions: Start Streaming Logs.

  2. Válassza ki a Function alkalmazást az Azure-ban, majd válassza az Igen lehetőséget az alkalmazás naplózásának engedélyezéséhez a Function alkalmazásban.Select your function app in Azure, and then select Yes to enable application logging for the function app.

  3. Aktiválja funkcióit az Azure-ban.Trigger your functions in Azure. Figyelje meg, hogy a naplózási adatokat a rendszer a Visual Studio Code kimenet ablakában jeleníti meg.Notice that log data is displayed in the Output window in Visual Studio Code.

  4. Ha elkészült, ne felejtse el futtatni a parancsot Azure functions: Állítsa le a folyamatos átviteli naplókat a Function alkalmazás naplózásának letiltásához.When you're done, remember to run the command Azure Functions: Stop Streaming Logs to disable logging for the function app.

Alapvető eszközökCore Tools

Beépített log streamingBuilt-in log streaming

Az Azure logstream -ban futó adott Function app-beli adatfolyam-naplók fogadásának megkezdéséhez használja a következő példát:Use the logstream option to start receiving streaming logs of a specific function app running in Azure, as in the following example:

func azure functionapp logstream <FunctionAppName>

Élő metrikastreamLive Metrics Stream

A Function alkalmazáshoz tartozó élő metrikastream egy új böngészőablakban is megtekintheti a --browser lehetőséggel együtt, az alábbi példában látható módon:You can also view the Live Metrics Stream for your function app in a new browser window by including the --browser option, as in the following example:

func azure functionapp logstream <FunctionAppName> --browser

Azure parancssori felület (CLI)Azure CLI

Az Azure CLIhasználatával engedélyezheti a folyamatos átviteli naplókat.You can enable streaming logs by using the Azure CLI. A következő parancsokkal jelentkezzen be, válassza ki az előfizetését és a stream naplófájljait:Use the following commands to sign in, choose your subscription, and stream log files:

az login
az account list
az account set --subscription <subscriptionNameOrId>
az webapp log tail --resource-group <RESOURCE_GROUP_NAME> --name <FUNCTION_APP_NAME>

Azure PowerShellAzure PowerShell

Azure PowerShellhasználatával engedélyezheti a folyamatos átviteli naplókat.You can enable streaming logs by using Azure PowerShell. A PowerShell esetében használja az alábbi parancsokat az Azure-fiók hozzáadásához, és válassza ki az előfizetését és a stream naplófájljait:For PowerShell, use the following commands to add your Azure account, choose your subscription, and stream log files:

Add-AzAccount
Get-AzSubscription
Get-AzSubscription -SubscriptionName "<subscription name>" | Select-AzSubscription
Get-AzWebSiteLog -Name <FUNCTION_APP_NAME> -Tail

Beépített naplózás letiltásaDisable built-in logging

A Application Insights engedélyezésekor tiltsa le az Azure Storage-t használó beépített naplózást.When you enable Application Insights, disable the built-in logging that uses Azure Storage. A beépített naplózás hasznos a könnyű számítási feladatokkal történő teszteléshez, de nem a nagy terhelésű éles használathoz.The built-in logging is useful for testing with light workloads, but isn't intended for high-load production use. Éles monitorozáshoz ajánlott Application Insights.For production monitoring, we recommend Application Insights. Ha a beépített naplózást éles környezetben használja, előfordulhat, hogy a naplózási rekord nem fejeződött be az Azure Storage-ban való szabályozás miatt.If built-in logging is used in production, the logging record might be incomplete because of throttling on Azure Storage.

A beépített naplózás letiltásához törölje a AzureWebJobsDashboard alkalmazás beállítását.To disable built-in logging, delete the AzureWebJobsDashboard app setting. Az Alkalmazásbeállítások a Azure Portalban való törlésével kapcsolatos további információkért tekintse meg a functions-alkalmazás kezelésévelfoglalkozó témakör Alkalmazásbeállítások szakaszát.For information about how to delete app settings in the Azure portal, see the Application settings section of How to manage a function app. Az Alkalmazásbeállítások törlése előtt győződjön meg arról, hogy az azonos Function alkalmazásban lévő meglévő függvények nem használják az Azure Storage-eseményindítók és-kötések beállítását.Before you delete the app setting, make sure no existing functions in the same function app use the setting for Azure Storage triggers or bindings.

Következő lépésekNext steps

További információkért lásd a következőket:For more information, see the following resources: