TaskQueue | Support priority | Job Scheduling library

In QueueBackgroundWorkItemAsync(RunRegistrationCompanyMainAsync) call compiler actually performs cast from method group into a delegate. But to provide instance of Func delegate your are not limited to method groups, you can provide a lambda expression for example:

Twilio developer evangelist here.

When you redirect a call from a task, its task is cancelled with the reason "redirected" so you don't need to cancel it yourself.

Your code was failing to update the task occasionally because of a race condition between your code and the task getting cancelled by Twilio.

Twilio developer evangelist here.

To disable a queue from the Twilio console you could update the workflow so the expression that would match a queue always returns false. For example, by adding AND 1 == 0 to the expression.

Since no tasks would match that expression, they would skip that queue and move to the next queue in the workflow.

Check out the documentation for more on how workflows assign tasks to queues.

The www output target is meant for generating apps and not really relevant for component libraries. To host your components, you should upload the whole generated dist folder. Only the files that the client needs are downloaded, which depends on the client and which components they access (lazy-loading). So you don't need to worry about the amount of files. See https://stenciljs.com/docs/distribution.

To start, Stencil was designed to lazy-load itself only when the component was actually used on a page. There are many benefits to this approach, such as simply adding a script tag to any page and the entire library is available for use, yet only the components actually used are downloaded.

If you want to generate a single bundle containing all your components, there's an output target called dist-custom-elements-bundle. For the differences to dist you can have a look at the same docs link above.

One of the main differences is that loading the script doesn't automatically register the components for you, you'll have to either do it manually per component (using customElements.define(), or define them all using the defineCustomElements() export. The official documentation for that output target is https://stenciljs.com/docs/custom-elements.

Twilio developer evangelist here.

It looks like your function is written mostly correctly and should return. There's two things I can think of that might be going wrong.

I'm not sure how many queues you have, but getting all the queues and then getting all the statistics for each queue could just be pushing your Function over the 10 second limit for Function execution. If that is the case, then may have to break up the Function so that it can run within the time. Are you able to run this locally (using the Twilio Serverless Toolkit) and it succeed?

Your code looks right to me, but the way you wrap the results of API calls in a new promise means that if there is an error the wrapper promise never resolves or rejects. This would mean that the Function hangs waiting for a result until the timeout occurs.

Thing is, you don't need to wrap the API calls in a new Promise, they already return Promises.

I would try rewriting it like this, avoiding new Promise wrappers and then seeing if there is an error that you aren't catching. You can also avoid pushing promises into an array and jump straight into the Promise.all too:

Using an external queue has some advantages over in-memory queueing. In particular, the queue message are stored in a reliable external store with features around retries, multiple consumers, etc. If your app crashes, the queue item remains and can be tried again.

In Azure, you can use several services including Azure Storage Queues and Service Bus. I like Service Bus because it uses push-based behavior to avoid the need for a polling loop in your code. Either way, you can create an instance of IHostedService that will watch the queue and process the work items in a separate thread with configurable parallelization.

Look for examples on using within ASP.NET Core, for example:

https://damienbod.com/2019/04/23/using-azure-service-bus-queues-with-asp-net-core-services/

The Zalgo situation the author is referring to would be

The problem is that you are not passing a Map,Job>, you are passing a Map. The reason is that generics in Java are not covariant, complicated by the fact that although TaskType is an Enum, and the only possible Enum, an Enum in the Java typesystem is not a TaskType.

You need to change the signature of your method to either use:

• Map (accepts only maps with TaskType as key), or
• Map

Similarly, it would probably be better to change the type of the taskType parameter to E as well.