callStack | Call stack controller | Runtime Evironment library

If you are sure that the key is present then you can use fromJust to turn the Maybe User into a User:

You might need to install GCC, which, as far as I can tell by looking at the MSYS2 setup on my machine, doesn't seem to come with the initial MSYS2 install. That would be done through pacman, on the MSYS shell (see the MSYS2 wiki for a primer on the MSYS2 shells and subsystems):

The current React Native Bridge architecture between Native and JS works asynchronously and transfer data in JSON only.

It produces next issues:

Async calls

• Many threads and jumps across them: JS, Shadow, Main, Native...
• JS and Main threads do not directly communicate (slow UI rendering)

JSON

• No data sharing between JS and Native threads
• Slow data transfer because of JSON serialisation (bottleneck)

You can make the bridge to any native code Java/Konlin, ObjC/Swift, C++ etc. but you always have the problems from above.

React Native JSI provides API to JS Runtime engine and allows to expose native functions and objects to JS directly - no bridge at all.

It provides next advantages:

• Sync call from JS thread to Native and vice-versa
• Fast rendering using direct call to UI Main thread
• Data sharing between threads

You have to use C++ only to work with JSI because JS Runtime has C++ API but it is possible to make C++ layer between JSI and your existed Java or Swift code.

JSI is foundation for future new React Native architecture which includes: Fabric, TurboModules, CodeGen. Read more: https://github.com/react-native-community/discussions-and-proposals/issues/91

The following fixes the problem:

what do you mean by only 14 frames ?
do you do enough operations after you enable !htrace for htrace to collect traces ?
as far as i can tell there is no 14 frame limit
just to confirm i attached cdb to a running instance of notepad++ and logged the traces

cdb -pn notepad++
!htrace -enable
.logopen d:\htrace.txt
g
open closed several tabs about , plugins etc to possibly collect
broke back with ctrl+c
did !htrace and quit and awk grepped the htrace.txt

i can see a lot of traces and frames > 14 o a log 1.61 MB big for a few minutes

I think you can just use callStack.

Here's what it seems like you're trying to do:

Given a dictionary mapping keys (strings) to values (lists of strings), and a string-value to look up, first determine if the given value is present in the list contained in the last entry of the dictionary. If so, then censor the value and return it. Otherwise, determine if the given value is present in some value-list; if so, return the associated key. If not, return Nothing.

Wouldn't it make more sense to have the "list of strings that need censorship" be a separate argument? Then a solution would be:

This seems like a bug, I think the author of SBV forgot CRational in this pattern match:

https://github.com/LeventErkok/sbv/blob/cfaa40b8c8ff8e1b7ff9ab71304654f6f531ba72/Data/SBV/Core/Concrete.hs#L324-L336

I opened an issue: https://github.com/LeventErkok/sbv/issues/591

In general, you have 2 strategies:

1. Instrument your application with some sort of logging/tracing framework, and then try to replicate some sort of tracing mixin-like functionality to apply global/local tracing depending on which parts of code you apply the mixins.

2. Recompile your code with some sort of tracing instrumentation feature enabled for your compiler or runtime, and then use the associated tracing compiler/runtime-specific tools/frameworks to transform/sift through the data.

For 1, this will require you to manually insert more code or something like _penter/_pexit for MSVC manually or create some sort of ScopedLogger that would (hopefully!) log async to some external file/stream/process. This is not necessarily a bad thing, as having a separate process control the trace tracking would probably be better in the case where the traced process crashes. Regardless, you'd probably have to refactor your code since C++ does not have great first-class support for metaprogramming to refactor/instrument code at a module/global level. However, this is not an uncommon pattern anyways for larger applications; for example, AWS X-Ray is an example of a commercial tracing service (though, typically, I believe it fits the use case of tracing network calls and RPC calls rather than in-process function calls).

For 2, you can try something like utrace or something compiler-specific: MSVC has various tools like Performance Explorer, LLVM has XRay, GCC has gprof. You essentially compile in a sort of "debug++" mode or there is some special OS/hardware/compiler magic to automatically insert tracing instructions or markers that help the runtime trace your desired code. These tracing-enabled programs/runtimes typically emit to some sort of unique tracing format that must then be read by a unique tracing format reader.

Finally, to dynamically build the graph in memory is a a similar story. Like the tracing strategies above, there are a variety of application and runtime-level libraries to help trace your code that you can interact with programmatically. Even the simplest version of creating ScopedTracer objects that log to a tracing file can then be fitted with a consumer thread that owns and updates the trace graph with whatever desired latency and data durability requirements you have.