servicefabric | Unofficial Service Fabric Golang API | REST library

You can use dynamic blocks. Basically, first is always created, while second is optional:

There are two options to do it with Application Insights. Both are not ideal at this point.

Option I. If you store all telemetry in the same resource and your app doesn't have too much load then you can group by (summarize) by CorrelationId. Here is an idea (you might want to extend it by recording start time when it comes to Application 1 and end time when it comes to Application 3):

After some contact (https://github.com/microsoft/ApplicationInsights-ServiceFabric/issues/115) the issue became clear.

It's because of the new version of AppInsight is using a new protocol, which is in the .net version of the library. You can force AppInsights to use the "old" protocol and then the end to end trace works again. You can to this by setting the ActivityIDformat property to legacy one like below. (somewhere in app startup)

It was another traffic protection tool. Although it was possible to telnet the port, still traffic from app was blocked by another tool.

You're on the right track!

• Step 1.

The classes ConfigurationSection and ConfigurationProperty are in SF namespace System.Fabric.Description. Add a using for the namespace

• Step 2.

Please upgrade to ServiceFabric.Mocks v4.2.8. This adds support to mock the DataPackage property on MockCodePackageActivationContext. See this page for an example.

• Step 3.

Use the created context as a constructor argument. Change this code:

Yes, you can use the ServiceFabric.Mocks library, to create a test instance of your service by using the following code:

I had this same issue for the past day or so, and I was able to resolve the issue by searching my OS(C://) drive for the first part of the key name {first part}_{the rest}.

I found a copy/original key in "C:\Users\youruser\AppData\Roaming\Microsoft\Crypto\Keys" and copied it over to "C:\ProgramData\Microsoft\Crypto\Keys".

After doing this the app was able to run and deploy again on my local machine.

The Garbage Collector is a strange beast, so it's worth getting to know about its behaviour. (Note, this is a simplistic view of the GC)

First of all, if just one reference exists to an object, that object is not considered garbage, so it will never be collected. As your Dictionary is static, it is always going to exist, so anything contained within it will always have a reference to it. If there are no other references to the contained object and you remove it from the Dictionary, it will become unreachable and therefore garbage and will be collected. Making sure there are no references to your objects is the way to ensure they will be collected. It's very easy to forget about some reference you made somewhere, which keeps the object alive.

Secondly, the Garbage Collector doesn't run continuously. It runs when memory resources are getting low and needs to release some memory. This is so that it doesn't hog the CPU to the detriment of the main applications. This means that objects can still be in memory for some time before the next Garbage Collection. This can make memory usage seem high at times, even when it isn't.

Thirdly, the Garbage Collector has "Generations". Generation 0 objects are the newest and most short-lived objects. Generation 0 objects are collected most often, but only when memory is needed.

Generation 1 contains short-lived objects that are on their way to becoming long-lived objects. They are collected less often that Generation 0 objects. In fact, Generation 1 collection only happens if a Generation 0 collection did not release enough memory.

Generation 2 objects are long-lived. These are typically things like static objects which exist for the lifetime of the application. Similarly, these are collected when the Generation 1 collection doesn't release enough memory.

Finally, there is the Large Object heap. Objects that consume a lot of memory take time to move around (part of the garbage collection process involves defragmenting the memory after collection has taken place), so they tend to remain uncollected unless collection didn't release enough memory. Some people refer to this as Generation 3, but they are actually collected in Generation 2 when necessary.

I believe you are running into an existing issue with remoting v2. V2 requires Remoting Api Types be of concrete Type.

• don't use IEnumerable but string[] in contracts.
• or provide a custom implementation of IServiceRemotingMessageSerializationProvider