* Sighs *
Keep creating posts with similar meaning and you'll get downvoted quickly. Although we are here to help you, you could at least try using the search feature and also recompensate us by checking the correct answer.

My first idea is to use a captcha service straight from China.

Something like this:
http://www.yinxiangma.com/
Maybe if you use some flag to fallback to this service instead of reCaptcha when the consumer originates from mainland China.
The only issue is that you might need a translator for support.

There's no embedded or native way of doing so, due to, well... security concerns.

There're scripts and third party programs that allow you to do something close to it.
https://stackoverflow.com/questions/19098101/how-to-open-an-elevated-cm…
However, should you really be executing it with admin privileges? Why not make your executable accessible for your Caché user, so that you won't need to elevate your prompt?

No, you can't. Unless you ovewrite some methods from %CSP.REST, like DispatchMethod.
 

Even so, simply ovewritting it wouldn't give you data about arguments that your dispatch method received, you need to go further than that and modify the way the info about the route is generated.
I also had headaches with that, because the pattern generation algorithm simply replaces any :placeholder by it's regular expression group counterpart, e.g. for Route elements /:msg becomes /([^/]+), but there're some variations according to which element you use to define it: Map or Route.
When compile your class, a method generator runs and creates a DispatchMap that takes an index, this index contains info about your dispatch method, http method and pattern to match. This index is based on the order you defined each element.
However DispatchMap does not generate info about the name of the parameter affected, only their index, so you would need to parse it by opening the dispatch method's class %Dictionary.CompiledMethod and accessing each Property's FormalSpec and matching their index to find the name of the argument.
This is some of the reasons why I implemented this, because I found %CSP.REST very limited. And what you want is something that I call: Reporter. It's a an abstract module that runs custom implementations whenever a method ends abnormally. I already implemented a sample of it for reporting an error via e-mail. 
EDIT: I just noticed that you want something to run for every request, regardless of success or error. I'll work on it.
You must notice two methods as declared here. These are the methods that should be implemented.  After that you only need to register the setup class with your router class. If you want to see it quickly, just change the commented reporter to this one and configure your e-mail parameters.
Finally, you can use %OAuth2's JWT implementation to store info about your current user. I'd recommend you to read this tutorial to learn how to setup it.
And if you want to read more about how my implementation works, you can find it out here.

Are you trying to execute some binary outside Caché or is it related to your current Caché process? By the type of the value you used as example, I'm attempted to say it's related to the JVM. If so, you can set most of the values using the its command-line arguments, including the heap size.
If that's related to your current process, you could trying doing the inverse procedure and capture the values from a .env file instead, it seems you can't get freshly set env variables because for the OS the Caché is already a running process. Maybe you can work around it using by source 'ing a script file that sets it, but I haven't tried.
However, I'd still go with the .env file instead. I did a little utility sometime ago because I thought it would be useful someday

Not sure if that's right, but maybe you're asking for this? You can do whatever you want on each iteration, including delete the obsolete files.

Try sending the CreatedDate format like this, which is the format used by JSON serializers.
"2019-08-26T16:38:26.893Z"

If you don't want to hook Caché with another language using Caché Bindings, you should use PBKDF2 with SHA256. Otherwise you'll need some external implementation to use bcrypt.

write $System.Encryption.PBKDF2("secret", 15000, $System.Encryption.GenCryptRand(64), 64, 256)

Although IS should really implement bcrypt and Argon with native support.

You need to generate a SSL configuration and provide to your request object by using the SSLConfiguration property, after this you must also inform to your request that you want to use a secure connection by enabling the property Https.

Here's how we send a push using OneSignal:

 set client = ##class(%Net.HttpRequest).%New()
 set client.Server = "onesignal.com"

 // You'll need to generate the configuration to be used below, you can decide its name.
 set client.SSLConfiguration = "OneSignal SSL Config"

 set client.Https = 1
 set client.Authorization = $$$FormatText("Basic %1", $get(^App.Envs("ONESIGNAL_KEY")))
 set client.ContentCharset = "utf-8"
 set client.ContentType = "application/json"
 set client.ContentEncoding = "utf-8"
 set client.NoDefaultContentCharset = 0
  
 set body = {
   "app_id": ($get(^App.Envs("ONESIGNAL_APPID"))),
   "data": (data),
   "contents": {
       "en": (message),
       "pt": (message)
   },
    "filters": (filters)
}
  
  set json = body.%ToJSON()
  do client.EntityBody.Write(json)
    
  set sc = client.Post("/api/v1/notifications")
  return sc

You can generate that SSL configuration using the portal, you can also something like this:

ClassMethod CreateSSLConfigurationIfNoneExists(name As %String)
{
   new $namespace
   set $namespace = "%SYS"
      
   do ##class(Security.SSLConfigs).Get(name, .p)
   if $data(p) quit   
   
   set p("CipherList")="ALL:!aNULL:!eNULL:!EXP:!SSLv2"
   set p("CAFile")=""
   set p("CAPath")=""
   set p("CRLFile")=""
   set p("CertificateFile")=""
   set p("CipherList")="ALL:!aNULL:!eNULL:!EXP:!SSLv2"
   set p("Description")=""
   set p("Enabled")=1
   set p("PrivateKeyFile")=""
   set p("PrivateKeyPassword")=""
   set p("PrivateKeyType")=2
   set p("Protocols")=24
   set p("SNIName")=""
   set p("Type")=0
   set p("VerifyDepth")=9
   set p("VerifyPeer")=0
   
   do ##class(Security.SSLConfigs).Create(name, .p)
}

Looks like there's a pvaoref property that points to the original instance as you can see below:

Method %OnNew(oref As %Library.DynamicAbstractObject) As %Status [ Private, ProcedureBlock = 1, ServerOnly = 1 ]
{
	set i%pointer = -1
	set ..pvaoref = oref
	return $$$OK
}

And it seems to work:

USER>set a = []
 
USER>set it = a.%GetIterator()
 
USER>w it.pvaoref
1@%Library.DynamicArray
USER>

I think it is:

write %request.GetCgiEnv("HTTP_APPLICATION_ID")

Although by convention, custom headers should begin with a X character to avoid possible conflicts with future but spec-based implementations.

For your version, you'll need to create your own serializer.
Here's an idea on how to do it.

Try defining these settings and see if that solves your issue.

set httpRequest.ContentCharset = "utf-8"
set httpRequest.ContentType = "application/json"
set httpRequest.ContentEncoding = "utf-8"
set httpRequest.NoDefaultContentCharset = 0 // Specifically this one.