AppEngine Functions (Serverless Functions)

  • 4min

Please note that invocation of AppEngine Functions can trigger the ingest (and therefore implicitly the retention) of additional data or the execution of a DQL query. This might generate additional consumption of Ingest & Process, Retain, and Query dimensions, depending on the use cases.

Here's what's available to assist you in understanding your organization's consumption of AppEngine Functions:

Concept

Explanation

Works out-of-the-box

No external hosting required, no need to worry about maintaining a runtime environment to execute logic or code

Extend the platform

  • Fetch data (not persisted in Grail) live from external APIs
  • Connect to APIs in the cloud and on premises (with EdgeConnect)
  • Dedicated APIs to push data from external systems
  • Custom APIs with specific semantics

Data processing

  • Data processing, for example, to aggregate data persisted in Dynatrace and external data
  • Data transformation to make external and aggregated data easily consumable within the Dynatrace web UI
  • Connect apps with external databases and normalize data for immediate platform-wide use

Enterprise readiness; Secure analytics (run-time)

  • No firewall or network configuration changes necessary for incoming connections
  • Secure and sandboxed execution in the context of your existing policies
  • Authentication and authorization (permission handling)

There are three types of AppEngine Functions:

  • App functions: These functions represent the backend of an app and are built, bundled, and deployed together with your custom app.

  • Ad-hoc functions: Custom code that accomplishes a specific use case is referred to as an ad-hoc function. These functions can be invoked from within Notebooks Notebooks, Dashboards Dashboards, Workflows Workflows, or directly via API.

  • Custom actions: A specific type of app function that, together with a UI component, can be declared as a custom workflow action to extend Workflows Workflows. Custom actions can then be selected as a task within Workflows Workflows and can be executed within a workflow.

All AppEngine Functions are deployed in an environment with 256 MiB RAM.

Billable consumption of AppEngine functions occurs when:

  • App functions are invoked in a custom app.
  • Ad-hoc functions are invoked in Notebooks Notebooks, Dashboards Dashboards, Workflows Workflows, or directly via API.
  • Custom actions are invoked in workflow.

The unit of measure for consumption of AppEngine Functions is an invocation. In this context, Dynatrace defines one invocation as each minute (or part thereof) of execution time for a single function call. One function call will consume either one or two invocations:

  • 0–60 seconds: one invocation.
  • 61–120 seconds: two invocations.
  • After 120 seconds, the function call will time out.

The total consumption is calculated by multiplying the number of invocations by your rate card price per invocation.

Consumption details

To help you understand and analyze your organization's consumption of AppEngine Functions - Small, Dynatrace provides usage details that can be queried via DQL, for example, in Notebooks Notebooks or via the Environment API. Relevant queries are also available in Account Management (Usage summary > AppEngine Functions - Small > Actions > View details).

While you can link directly to your Dynatrace environment from Account Management, you can also copy and paste DQL queries into a notebook to analyze consumption of AppEngine Functions.

The following DQL query provides an overview of daily AppEngine Function invocations by function type:

fetch dt.system.events, scanLimitGBytes: -1
| filter event.type == "AppEngine Functions - Small" AND event.kind == "BILLING_USAGE_EVENT" AND (billing_type == "BILLABLE" OR isNull(billing_type))
| fieldsAdd data = if(matchesPhrase(function.type, "AD_HOC"), "Ad-hoc", else: if(matchesPhrase(function.type, "ACTION"), "Actions", else: if(matchesPhrase(function.type, "STANDARD"), "App functions")))
| summarize billed_invocations = takeAny(billed_invocations), by:{timestamp=bin(timestamp, 1d), event.id,data}
| summarize invocations = sum(if(billed_invocations,billed_invocations,else:1)), by:{data, timestamp}
| sort timestamp desc, invocations desc

The following DQL query provides details on users and apps using AppEngine Functions:

fetch dt.system.events, scanLimitGBytes: -1
| filter event.type == "AppEngine Functions - Small" AND event.kind == "BILLING_USAGE_EVENT" AND (billing_type == "BILLABLE" OR isNull(billing_type))
| summarize billed_invocations = takeAny(billed_invocations), by:{startHour = bin(timestamp, 1h), event.id, user.email, caller.app.id}
| summarize Invocations = sum(if(billed_invocations,billed_invocations,else:1)), by:{User = user.email, Calling_App = caller.app.id}
| sort Invocations desc