gotcha | convenient way to track amount

Consider the signature of Future.sequence in Scala 2.13

Well yes - the Change Tracker of course can only track whatever you've changing / modifying / adding through means of the DbContext class.

Running a stored procedure is outside the scope of the EF Change Tracker - so if you base your "rollback" on simply things in the Change Tracker, you won't be able to properly handle anything your stored procedure have done.

Using TransactionScope is fundamentally different - this is an "umbrella" over all the database operations - including any stored procedures being executed - since it's basically on the database's level. So rolling back based on the transaction scope will roll back all database operations - whether handled via the EF DbContext, or via other means.

The JmsTemplate reliably closes its resources after each operation (returning the session to the cache), including execute().

That comment is related to user code using sessions directly; the close operation is intercepted and used to return the session to the cache, instead of actually closing it. You MUST call close, otherwise the session will be orphaned.

Yes, the transaction will roll back (immediately) if its sessionTransacted is true.

You should NOT call commit - the template will do that when execute exits normally (if it is sessionTransacted).

Is there a defensive programming practice that can help avoid these problems and provide early detection?

Yes. Accidental captures are easily detected by always including what PEP 634 describes as an irrefutable case block.

In plain language, that means a catchall case that always matches.

Accidental captures always match. No more than one irrefutable case block is permitted. Therefore, accidental captures are detected immediately when an intentional catchall is added.

Just add a catchall wildcard pattern to the end:

On the context of a view functions, there is no such thing as:

• signer_account_id
• signer_account_pk
• predecessor_account_id

It is not required to sign any message to run a view function, and moreover it is not allowed. It is more like inspecting a contract anonymously, nothing should be paid for that, and the result is independent from the caller. Because of this there is no signer_account_id and signer_account_pk.

On the other hand, it is not possible to make a cross-contract call, if you are initiating this call in view mode. Because of this there is no predecessor_account_id available, since signer_account_id is not available, and it is impossible that this was called from another contract.

This is a common gotcha indeed - I've seen several bugs due to similar.

In short:

• no, you're not always required to await a task, and sometimes it can be actively advantageous to avoid the overhead of the async machinery - especially in tight code like file/network IO loop, but (and it is a big but)
• if that means you're escaping a try/finally region (which also includes using and lock, although there are other bigger problems with lock in async code), then you need to take that into consideration, which usually means "yes, you need to await"

It would be nice if there was an analyzer that spotted the return of a Task[]/ValueTask[] in a non-async method, inside such a region, as it is almost always a bug, and for the few times that it isn't (where the finally has nothing to do with the thing being returned) it could be suppressed.

The / sign is a special character in flex. It's used for lookaheads and the way you're using it is illegal (flex only allows lookaheads at the very end of the expression, not inside groups).

Since you don't actually want a lookahead, but to match a literal slash, you should either put it in quotes or escape it with a backslash.

Cloud Run services are only reachable through HTTP request. you can't use other network protocol (SSH to log into instances for example, or TCP/UDP communication).

However, Cloud Run can initiate these kind of connection to external services (for instance Compute Engine instances deployed in your VPC, thanks to the serverless VPC Connector).

the serverless VPC connector allow you to make a bridge between the Google Cloud managed environment (where live the Cloud Run (and Cloud Functions/App Engine) instances) and the VPC of your project where you have your own instances (Compute Engine, GKE node pools,...)

Thus you can have a Cloud Run service that reach a Kubernetes pods on GKE through a TCP connection, if it's your requirement.

About service discovery, it's not yet the case but Google work actively on that and Ahmet (Google Cloud Dev Advocate on Cloud Run) has released recently a tool for that. But nothing really build in.

Using UnmanagedExports this is really quite easy.

You start with an interface for the functionality, like so: