ad-blocking | ad blocking techniques | Browser Plugin library

Don't. Get in the habit of writing async code in node everywhere, even if it doesn't need to be. It's just good practice, prevents refactoring a bunch of stuff in the future, and with modern JS it's simple to write:

so I found the solution for my first challenge, instead of running my renderer directly with the child process, I had to build it first, so I used webpack to make a cjs output of it, then use that output in the child process.

and for increase the performance, even more, I used a combination of SSR and SSG, so in each request I check if a file mapped to the route exists on the server, if it's not, I'm gonna use SSR renderer output to create a file, and serve the response to the user, then for next request since the cached file exists I use that cache file instead of rendering the result again. finally I set a corn job on the server to clear the cache every 10 minute

It's pretty complicated, but I believe the cause of launch()/async() not executing is that their parent coroutineScope() already finished at this point in time. Notice "11" happens before "4", meaning that you invoked launch() after going out of coroutineScope(). Which makes sense, because inTransaction() starts asynchronous operation, so it returns immediately, without waiting for the inner code. To fix this, you just need to move cdf.await() inside coroutineScope().

Another thing that concerns me is that you await on completable that you created by yourself and not the one returned from inTransaction(). Note that it may be a totally different CompletableFuture and in that case you actually return before the operation completes.

Also, I'm not sure if this manual exception handling for completable is really necessary. async() already performs exception handling and wraps the result as CompleteableDeferred, then it is converted to CompletableFuture which also wraps exceptions. The only thing we have to do is to replace coroutineScope() with supervisorScope(). Otherwise, async() would automatically signal coroutineScope() to fail, so the exception handling would totally bypass inTransaction() function.

Try this code:

Seems like you're misunderstanding the concept of server-side GTM.

The idea here is that the endpoint of your server-side GTM (the G Engine instance) is never exposed on front-end.

So your back-end sends events to your App Engine instance, not the front-end. You typically don't need to deploy ANY code on the front-end. All logic is supposed to be set up solely on the backend. By your back-end developers. Your backend usually can listen to all the important events that are happening seemingly on the front-end. Like page navigations, form submissions, purchases, etc.

You still can send seemingly front-end events to your server-side GTM. But you have to be smart about it. You don't want to expose your real GTM endpoint exactly to avoid bots, "hackers" and adblockers.

So what you do instead, is:

1. Build a custom "mirror" endpoint on your backend the main idea of which is to relay everything it gets to your App Engine GTM endpoint. Actually, it doesn't matter where you build the mirror endpoint. Your backend team would likely frown upon the idea of analytics contributing to "their" repos, so it may be a good idea to own your endpoint.
2. Add protection, data enrichment, validation and logging to your mirror endpoint. It's optional, but it's good to have.
3. Now use your new endpoint for the rare cases when you need to add front-end tracking to your existing back-end tracking. Addblockers will still block your front-end GTM, so you likely want to use something else (NOT a TMS) for your front-end code.
4. Optionally, add some back-end logic to synchronize client ids between the backend events and your mirror endpoint events. And it's a lot easier if your mirror lives with your main back-end codebase, keep it in mind.

Yes, server-side brings a lot of elegant solutions to modern tracking. It, however, requires the implementation specialists to be full-stack web-devs. And it's not typical for the industry. In fact, it's rare for the implementators to have even mid-JS dev skills, not mentioning full-stack or REST API experience.

Try like this:

First of all its not entirely fair to compare C# to JavaScript - they are different languages with different runtimes and different asynchronous mechanisms.

JavaScript is not multi-threaded - it runs on one thread; hence cant actually do anything asynchronously. To over overcome this the JS runtime makes use of the event loop which lets you differentiate between code that needs to block the main thread and code that that shouldnt block (like and AJAX call - once an http request is sent there is nothing JS can do but wait, so instead it gets thrown on the event loop until the the http response is returned, then it will get pulled off the event loop and start executing and code that depends on the response). The 'async' and 'await' keywords are effectively syntactic sugar to wrap the functionality of a Promise: the following code -

Temporary hack - not the real solution to the real problem:

For some reason adding the old code:

I guess you're using the links to Pixabay's website as src for your images (hit.pageURL). Didn't you mean to use hit.previewURL?

I think I have figured it out, thanks to this article
it comes down to running in the background usingDispatchers.IO
the SOAP call can be regular function, no need for Deffered, etc.

I am using MVVM model with repository, so all the background work is happening on the Repository level, triggered by button press in the Fragment launched in the respective ViewModel, with limited scope

my SOAP call now looks like this