hyperion | Lightweight JSON specification from Verizon Digital Media | REST library

You may use "tolist" on an array to convert it to a list:

Akka.NET is trying to load hyperion serializer via Type.GetType("Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion") call, and fails to do that, because Lighthouse docker image does not include Akka.Serialization.Hyperion package.

So what you need to do is:

1. Clone Lighthouse repo and add Akka.Serialization.Hyperion package to Lighthouse project references
2. Build your own docker image and use it instead.

I managed to solve the above mentioned issues, thanks to Professor Abronsius pointing out that it would be a string.

My solutions were as follows:

Javascript:

Since the behavior of the document.querySelector() function requires that the DOM is ready and parsed, you could add this to your JS file and call your js files from wherever you like:

I think that you need to do the following thing:

So there are two issues going on here: actor performance and missing messages.

It's not clear from your writeup, but I'm going to make an assumption: 100% of these messages are going to a single actor.

The end-to-end throughput of a single actor depends on:

1. The amount of work it takes to route the message to the actor (i.e. through the sharding system, hierarchy, over the network, etc)
2. The amount of time it takes the actor to process a single message, as this determines the rate at which a mailbox can be emptied; and
3. Any flow control that affects which messages can be processed when - i.e. if an actor uses stashing and behavior switching, the amount of time an actor spends stashing messages while waiting for its state to change will have a cumulative impact on the end-to-end processing time for all stashed messages.

You will have poor performance due to item 3 on this list. The design that you are implementing calls Persist and blocks the actor from doing any additional processing until the message is successfully persisted. All other messages sent to the actor are stashed internally until the previous one is successfully persisted.

Akka.Persistence offers four options for persisting messages from the point of view of a single actor:

• Persist - highest consistency (no other messages can be processed until persistence is confirmed), lowest performance;
• PersistAsync - lower consistency, much higher performance. Doesn't wait for the message to be persisted before processing the next message in the mailbox. Allows multiple messages from a single persistent actor to be processed concurrently in-flight - the order in which those events are persisted will be preserved (because they're sent to the internal Akka.Persistence journal IActorRef in that order) but the actor will continue to process additional messages before the persisted ones are confirmed. This means you probably have to modify your actor's in-memory state before you call PersistAsync and not after the fact.
• PersistAll - high consistency, but batches multiple persistent events at once. Same ordering and control flow semantics as Persist - but you're just persisting an array of messages together.
• PersistAllAsync - highest performance. Same semantics as PersistAsync but it's an atomic batch of messages in an array being persisted together.

To get an idea as to how the performance characteristics of Akka.Persistence changes with each of these methods, take a look at the detailed benchmark data the Akka.NET organization has put together around Akka.Persistence.Linq2Db, the new high performance RDBMS Akka.Persistence library: https://github.com/akkadotnet/Akka.Persistence.Linq2Db#performance - it's a difference between 15,000 per second and 250 per second on SQL; the write performance is likely even higher in a system like MongoDB.

One of the key properties of Akka.Persistence is that it intentionally routes all of the persistence commands through a set of centralized "journal" and "snapshot" actors on each node in a cluster - so messages from multiple persistent actors can be batched together across a small number of concurrent database connections. There are many users running hundreds of thousands of persistent actors simultaneously - if each actor had their own unique connection to the database it would melt even the most robustly vertically scaled database instances on Earth. This connection pooling / sharing is why the individual persistent actors rely on flow control.

You'll see similar performance using any persistent actor framework (i.e. Orleans, Service Fabric) because they all employ a similar design for the same reasons Akka.NET does.

To improve your performance, you will need to either batch received messages together and persist them in a group with PersistAll (think of this as de-bouncing) or use asynchronous persistence semantics using PersistAsync.

You'll also see better aggregate performance if you spread your workload out across many concurrent actors with different entity ids - that way you can benefit from actor concurrency and parallelism.

There could be any number of reasons why this might occur - most often it's going to be the result of:

1. Actors being terminated (not the same as restarting) and dumping all of their messages into the DeadLetter collection;
2. Network disruptions resulting in dropped connections - this can happen when nodes are sitting at 100% CPU - messages that are queued for delivery at the time can be dropped; and
3. The Akka.Persistence journal receiving timeouts back from the database will result in persistent actors terminating themselves due to loss of consistency.

You should look for the following in your logs:

• DeadLetter warnings / counts
• OpenCircuitBreakerExceptions coming from Akka.Persistence

You'll usually see both of those appear together - I suspect that's what is happening to your system. The other possibility could be Akka.Remote throwing DisassociationExceptions, which I would also look for.

You can fix the Akka.Remote issues by changing the heartbeat values for the Akka.Cluster failure-detector in configuration https://getakka.net/articles/configuration/akka.cluster.html:

This is because SQL and PPL does not like special characters like dot or dash in table name.

For your first question - How to configure SP initiated SSO from Pingfed, and retrieve the user attributes from the Okta Idp connection. If you are using OpenToken which is a custom adapter, you can download from PingFederate download side, refer here. This custom adapter is the Opentoken adapter that transfers user attributes between the application and the PingFederate server. On the SP side, the OpenToken Adapter can be used to transfer user-identity information to the target SP application. On the IDP side the OpenToken adapter allows the PingFederate server to receive the user's identity from the IDP application.

Here is a note from PingFederate about OpenToken Adapter. Note: To integrate applications for use with the OpenToken Adapter, download an integration kit for PingFederate from the Ping Identity Downloads website and follow instructions for installing and using Agent Toolkits in the accompanying documentation. Follow the configuration instructions in this topic to set up the OpenToken Adapter to use with your applications.

For your second question - How I can map the attributes from the SAML assertion sent from Okta to Pingfed SP into an opentoken to my target application. For SAML connections, the IdP application can provide an authentication context to the service provider (SP) by including the authnContext attribute with the desired value in the secure token. The OpenToken doc will provide you more info on authnContext.
Here is a definition of Authncontext - Authentication context is defined as the information, additional to the authentication assertion itself, that the relying party may require before it makes an entitlements decision with respect to an authentication assertion. Such context may include, but is not limited to, the actual authentication method used. Here is configuring Authn Context in PingFederate.

Your actor isn’t looping so terminates after the first message

Add a