Functions FAQ
BETA
This Twilio product is currently available as a beta release. Some features are not yet implemented and others may be changed before the product is declared as Generally Available. Beta products are not covered by a Twilio SLA. Learn more about beta product support.
Why does my Function return 'runtime application timed out'?
There are two likely reasons your Function has completed with the error: 'runtime application timed out'.
The most common reason is that your Function has exceeded the 10-second execution time limit. You can determine this by looking at the execution logs on the Function instance page. The last log line after execution will tell you how many milliseconds the Function took to execute. If the processing time is greater than 10,000 milliseconds, then Twilio terminated your Function.
The other more subtle reason your Function ended with an application timeout is because of an incorrect invocation of callback(). If your Function does not call the callback() method or the method is unreachable, your Function will continue executing until it reaches the time limit and ultimately fails. A very common mistake is to forget to capture the catch() rejected state of a Promise and calling callback() there as well. The Function Execution documentation provides extensive details on the functionality and usage of the callback() method. Below are several examples of correct use of callback() to complete execution and emit a response.
Why isn't my code running?
The most common reason we have seen that a Function appears not to run is the misuse of callback. Your Function invocation terminates when it calls callback. If your request is asynchronous, for example, an API call to a Twilio resource, then you must call callback after the success response of the request has resolved. This would be in the then/catch blocks chained to a request, or after a request that uses the await keyword in an async context.
Can API Calls occur after a Function Execution has ended?
Yes! Outgoing API requests from inside a Function (either directly via axios/got, or through an SDK such as Twilio's) can still be in an enqueued state even after the execution of a Function has ended.
This happens if you make an asynchronous request that returns a Promise, and forget to either await it or chain on a .then handler. Here, the Function may finish execution before the request occurs or completes. Then, your request may be deferred, sit idle, and run on a subsequent Function invocation in your Service before our system cleans it up.
How do I keep this from happening?
Always be sure to wait for the Promises generated by your API calls and methods to resolve before invoking callback. Below are examples of improperly and properly handled asynchronous logic, one which uses .then chaining, and another using async/await syntax.
// An example of an improperly handled Promise
exports.handler = (context, event, callback) => {
const client = context.getTwilioClient();
client.messages.create({
body: "hi",
to: toNumber,
from: fromNumber,
});
return callback(null, 'success');
};
Using .then chaining
// An example of properly waiting for message creation to
// finish before ending Function execution
exports.handler = (context, event, callback) => {
const client = context.getTwilioClient();
client.messages
.create({
body: 'hi',
to: event.toNumber,
from: event.fromNumber,
})
.then((message) => {
return callback(null, `Success! Message SID: ${message.sid}`);
});
// Ideally, you would also have some .catch logic to handle errors
};
Using async/await
// An example of properly waiting for message creation to
// finish before ending Function execution
exports.handler = async (context, event, callback) => {
const client = context.getTwilioClient();
const message = await client.messages.create({
body: 'hi',
to: event.toNumber,
from: event.fromNumber,
});
return callback(null, `Success! Message SID: ${message.sid}`);
// Ideally, you would add some try/catch logic to handle errors
};
How do I construct Voice TwiML?
You can generate Voice TwiML using the Twilio Node library, which comes packaged within your Function.
How do I construct Messaging TwiML?
You can generate Messaging TwiML using the Twilio Node library, which comes packaged within your Function.
How do I return JSON?
Simply return your object as outlined in the Function Execution documentation or the following sample code:
Can I interact with the OPTIONS request?
No, you cannot interact with the pre-flight OPTIONS request that browsers send.
The Runtime client will automatically respond to OPTIONS requests with the following values:
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: *
Access-Control-Allow-Methods: GET, POST, OPTIONS
This means that all origins may access your Function, all headers are passed through, and that the only methods allowed to access your Function are GET, POST, and OPTIONS.
How do I send CORS headers?
You can send CORS headers by using the Twilio Response object described in this example.
Can I execute my Functions on a schedule?
Currently, Functions are event-driven and can only be invoked by HTTP.
Can I see examples of existing Functions?
Absolutely! You can find a variety of examples in the navigation bar as well as on our Function Examples page.
How many Functions can I create?
During the beta period, the UI editor can load and present up to 100 Functions or Assets by default. If a service has over 100 Functions or Assets, click on Load more to view the remaining resources, or the next 100 if there are more than that.
The Deploy All and Save buttons, and the ability to change Dependencies, will be disabled until all the Functions and Assets in the service have been loaded. Similarly, it is not possible to delete Functions or Assets until all the Functions or Assets are loaded for view.
To create and manage more Functions and/or Assets, we suggest using the Serverless Toolkit or the Functions and Assets API directly.
What limits are in place on Function invocation?
We limit Functions to 30 concurrent invocations — meaning that if you have over 30 Functions being invoked at the same time, you will see new Function invocations return with a 429 status code. To keep below the threshold, optimize your Functions to return as fast as possible — avoid artificial timeouts and use asynchronous calls to external systems rather than waiting on many API calls to complete.
Can I create temporary files when executing a Function?
Yes. See this blog post for a description and samples on how to store files for one-off usage.
Are there any Twilio resources for learning Node.js?
- Twilio Quest for JavaScript
- #javascript public Slack channel in Twilio Quest Slack
- Blog Posts around Asynchronous JavaScript techniques
- 5 Ways to Make HTTP Requests in Node.js using Async/Await
- Async/Await: The Hero JavaScript Deserved
- Asynchronous JavaScript: Introducing async and await
- Using RxJS Observables With JavaScript Async and Await
- Asynchronous JavaScript: Using RxJS Observables with REST APIs in Node.js
- Asynchronous JavaScript: Organizing Callbacks for Readability and Reusability
- Asynchronous JavaScript: Refactoring Callbacks to Promises in Node.js
Need some help?
We all do sometimes; code is hard. Get help now from our support team, or lean on the wisdom of the crowd by visiting Twilio's Community Forums or browsing the Twilio tag on Stack Overflow.