Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

"System.Runtime.Serialization.SerializationException: Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array." After Akka Upgrade from 1.3.14 to 1.4.48 #6760

Closed
ayooyeyipo opened this issue May 16, 2023 · 31 comments

Comments

@ayooyeyipo
Copy link

ayooyeyipo commented May 16, 2023

Version Information
Version of Akka.NET?
1.4.48
Which Akka.NET Modules?
Akka, Akka.Cluster, Akka.Remote, Akka.Cluster.Tools, Akka.Serialization.Hyperion, Hyperion
Describe the bug
After Akka upgrade from

          Akka, Akka.Cluster, Akka.Remote, Akka.Cluster.Tools 1.3.14 
              Akka.Serialization.Hyperion 1.3.14-beta
              Hyperion 0.9.12

To

            _Akka,  Akka.Cluster, Akka.Cluster.Tools, Akka.Remote 1.4.48
            Akka.Serialization.Hyperion 1.4.21
            Hyperion 0.10.2_

Service is getting this:
Deserialization failed for message with serializer id [-5] and manifest [:]. Transient association error (association remains live). Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]. Please create an issue in our GitHub at [https://github.com/akkadotnet/akka.net]
System.Runtime.Serialization.SerializationException: Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array.
---> System.IndexOutOfRangeException: Index was outside the bounds of the array.
at lambda_method(Closure , Stream , DeserializerSession )
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)
--- End of inner exception stack trace ---
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)
at Hyperion.Serializer.Deserialize[T](Stream stream)
at Akka.Serialization.HyperionSerializer.FromBinary(Byte[] bytes, Type type)
at Akka.Serialization.Serialization.Deserialize(Byte[] bytes, Int32 serializerId, String manifest)
at Akka.Remote.MessageSerializer.Deserialize(ExtendedActorSystem system, Payload messageProtocol)
at Akka.Remote.DefaultMessageDispatcher.Dispatch(IInternalActorRef recipient, Address recipientAddress, Payload message, IActorRef senderOption)
at Akka.Remote.EndpointReader.b__11_0(InboundPayload inbound)

To Reproduce
Steps to reproduce the behavior:
The service is in a cluster with another service, below is the second service Akka version

             _Akka,  Akka.Cluster,  Akka.Cluster.Tools, Akka.Remote (1.4.10) 
            Akka.Serialization.Hyperion (1.3.11-beta)
            Hyperion (0.9.16)_

The service is sending request to the second service Via Ask

Expected behavior
When the service send request to the second service it should get back a result

Actual behavior
it get back results 80% of the time, 25% of the time its ask timeout and the exception above("System.Runtime.Serialization.SerializationException: Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array."). Before the upgrade it was getting the back result 99% of the time and the exception above is new

Environment
Docker, .NET Core 3.1

Additional context
Akka Configuration of the service

 akka {
      stdout-loglevel = INFO
      loglevel = INFO
      log-config-on-start = on
      loggers=["Akka.Logger.Serilog.SerilogLogger, Akka.Logger.Serilog"]
      extensions = ["Akka.Cluster.Tools.PublishSubscribe.DistributedPubSubExtensionProvider,Akka.Cluster.Tools"]
      actor.provider = cluster
      remote {
        dot-netty.tcp
        {
          message-frame-size =  6MiB
          send-buffer-size =  6MiB
          receive-buffer-size =  6MiB
          maximum-frame-size = 6MiB
          port = *****
        }
      }
      cluster {
        roles = ["receptionist"]
        allow-weakly-up-members = on
        shutdown-after-unsuccessful-join-seed-nodes = 30s
        downing-provider-class = "Akka.Cluster.SplitBrainResolver, Akka.Cluster"
        split-brain-resolver {
  		    active-strategy = keep-majority
           keep-majority {
			      role = receptionist
		      }
		      stable-after = 20s
	      }
	      down-removal-margin = 20s
      }

	  actor.serializers {
		  hyperion = "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion"
		}
		actor.serialization-bindings {
		  "Akka.IO.Client.ClientMessage, Akka.IO.Client" = hyperion
		}
    io.tcp.direct-buffer-pool.buffer-size = 262144
}
@Aaronontheweb
Copy link
Member

What version of Hyperion are you using?

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 16, 2023

I am using Hyperion version 0.10.2 (I upgraded from Akka.Serialization.Hyperion 1.3.14-beta & Hyperion 0.9.12 to Akka.Serialization.Hyperion 1.4.2 &Hyperion 0.10.2)

@Aaronontheweb
Copy link
Member

Deserialization failed for message with serializer id [-5] and manifest [:]. Transient association error (association remains live). Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]

Yep, that's Hyperion's id alright:

@Aaronontheweb
Copy link
Member

Not sure why Status.Failure is being handled by Hyperion. In Akka.NET v1.4.47 we added a dedicated Protobuf layer to handle it: #6297

That's one issue, but the yours is simpler:

Cause: Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]. 

This is a configuration problem - Hyperion is missing from your system's configuration. Can you please provide your configuration and any Setup classes you're using to configure your ActorSystem?

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 16, 2023

akka {
stdout-loglevel = INFO
loglevel = INFO
log-config-on-start = on
loggers=["Akka.Logger.Serilog.SerilogLogger, Akka.Logger.Serilog"]
extensions = ["Akka.Cluster.Tools.PublishSubscribe.DistributedPubSubExtensionProvider,Akka.Cluster.Tools"]
actor.provider = cluster
remote {
dot-netty.tcp
{
message-frame-size = 6MiB
send-buffer-size = 6MiB
receive-buffer-size = 6MiB
maximum-frame-size = 6MiB
port = *****
}
}
cluster {
roles = ["receptionist"]
allow-weakly-up-members = on
shutdown-after-unsuccessful-join-seed-nodes = 30s
downing-provider-class = "Akka.Cluster.SplitBrainResolver, Akka.Cluster"
split-brain-resolver {
active-strategy = keep-majority
keep-majority {
role = receptionist
}
stable-after = 20s
}
down-removal-margin = 20s
}

  actor.serializers {
	  hyperion = "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion"
	}
	actor.serialization-bindings {
	  "Akka.IO.Client.ClientMessage, Akka.IO.Client" = hyperion
	}
io.tcp.direct-buffer-pool.buffer-size = 262144
}

@ayooyeyipo
Copy link
Author

That is the akka configuration

@Aaronontheweb
Copy link
Member

Ah got it, sorry I missed that earlier in your post.

"Akka.IO.Client.ClientMessage, Akka.IO.Client" = hyperion

So given that strict binding, why would a Status.Failure message be serialized by Hyperion? That's odd.

What output do you get when you start your ActorSystem with akka.log-config-on-start = on ?

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 16, 2023

akka : {
    version : "0.0.1 Akka"
    home :
    loggers : ["Akka.Logger.Serilog.SerilogLogger, Akka.Logger.Serilog"]
    loggers-dispatcher : akka.actor.default-dispatcher
    logger-startup-timeout : 5s
    logger-async-start : false
    loglevel : INFO
    suppress-json-serializer-warning : on
    stdout-loglevel : INFO
    stdout-logger-class : Akka.Event.StandardOutLogger
    log-config-on-start : on
    log-dead-letters : 10
    log-dead-letters-during-shutdown : off
    log-dead-letters-suspend-duration : "5 minutes"
    extensions : [Akka.Cluster.Tools.PublishSubscribe.DistributedPubSubExtensionProvider,Akka.Cluster.Tools]
    daemonic : off
    actor : {
      provider : cluster
      guardian-supervisor-strategy : Akka.Actor.DefaultSupervisorStrategy
      creation-timeout : 20s
      reaper-interval : 5
      serialize-messages : off
      serialize-creators : off
      unstarted-push-timeout : 10s
      ask-timeout : infinite
      telemetry : {
        enabled : false
      }
      typed : {
        timeout : 5
      }
      inbox : {
        inbox-size : 1000
        default-timeout : 5s
      }
      router : {
        type-mapping : {
          from-code : Akka.Routing.NoRouter
          round-robin-pool : Akka.Routing.RoundRobinPool
          round-robin-group : Akka.Routing.RoundRobinGroup
          random-pool : Akka.Routing.RandomPool
          random-group : Akka.Routing.RandomGroup
          smallest-mailbox-pool : Akka.Routing.SmallestMailboxPool
          broadcast-pool : Akka.Routing.BroadcastPool
          broadcast-group : Akka.Routing.BroadcastGroup
          scatter-gather-pool : Akka.Routing.ScatterGatherFirstCompletedPool
          scatter-gather-group : Akka.Routing.ScatterGatherFirstCompletedGroup
          consistent-hashing-pool : Akka.Routing.ConsistentHashingPool
          consistent-hashing-group : Akka.Routing.ConsistentHashingGroup
          tail-chopping-pool : Akka.Routing.TailChoppingPool
          tail-chopping-group : Akka.Routing.TailChoppingGroup
          cluster-metrics-adaptive-pool : "Akka.Cluster.Metrics.AdaptiveLoadBalancingPool, Akka.Cluster.Metrics"
          cluster-metrics-adaptive-group : "Akka.Cluster.Metrics.AdaptiveLoadBalancingGroup, Akka.Cluster.Metrics"
        }
      }
      deployment : {
        default : {
          dispatcher :
          mailbox :
          router : from-code
          nr-of-instances : 1
          within : "5 s"
          virtual-nodes-factor : 10
          routees : {
            paths : <<unknown value>>
          }
          resizer : {
            enabled : off
            lower-bound : 1
            upper-bound : 10
            pressure-threshold : 1
            rampup-rate : 0.2
            backoff-threshold : 0.3
            backoff-rate : 0.1
            messages-per-resize : 10
          }
          remote :
          target : {
            nodes : <<unknown value>>
          }
          metrics-selector : mix
          cluster : {
            enabled : off
            max-nr-of-instances-per-node : 1
            max-total-nr-of-instances : 10000
            allow-local-routees : on
            use-role :
          }
        }
      }
      synchronized-dispatcher : {
        type : SynchronizedDispatcher
        executor : current-context-executor
        throughput : 10
      }
      task-dispatcher : {
        type : TaskDispatcher
        executor : task-executor
        throughput : 30
      }
      default-fork-join-dispatcher : {
        type : ForkJoinDispatcher
        executor : fork-join-executor
        throughput : 30
        dedicated-thread-pool : {
          thread-count : 3
          threadtype : background
        }
      }
      default-dispatcher : {
        type : Dispatcher
        executor : default-executor
        default-executor : {
        }
        thread-pool-executor : {
        }
        fork-join-executor : {
          parallelism-min : 8
          parallelism-factor : 1.0
          parallelism-max : 64
          task-peeking-mode : FIFO
        }
        current-context-executor : {
        }
        shutdown-timeout : 1s
        throughput : 30
        throughput-deadline-time : 0ms
        attempt-teamwork : on
        mailbox-requirement :
      }
      internal-dispatcher : {
        type : Dispatcher
        executor : fork-join-executor
        throughput : 5
        fork-join-executor : {
          parallelism-min : 4
          parallelism-factor : 1.0
          parallelism-max : 64
        }
        channel-executor : {
          priority : high
        }
      }
      default-blocking-io-dispatcher : {
        type : Dispatcher
        executor : thread-pool-executor
        throughput : 1
      }
      default-mailbox : {
        mailbox-type : Akka.Dispatch.UnboundedMailbox
        mailbox-capacity : 1000
        mailbox-push-timeout-time : 10s
        stash-capacity : -1
      }
      mailbox : {
        requirements : {
          Akka.Dispatch.IUnboundedMessageQueueSemantics : akka.actor.mailbox.unbounded-queue-based
          Akka.Dispatch.IBoundedMessageQueueSemantics : akka.actor.mailbox.bounded-queue-based
          Akka.Dispatch.IDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
          Akka.Dispatch.IUnboundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
          Akka.Dispatch.IBoundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.bounded-deque-based
          Akka.Dispatch.IMultipleConsumerSemantics : akka.actor.mailbox.unbounded-queue-based
          Akka.Event.ILoggerMessageQueueSemantics : akka.actor.mailbox.logger-queue
        }
        unbounded-queue-based : {
          mailbox-type : Akka.Dispatch.UnboundedMailbox
        }
        bounded-queue-based : {
          mailbox-type : Akka.Dispatch.BoundedMailbox
        }
        unbounded-deque-based : {
          mailbox-type : Akka.Dispatch.UnboundedDequeBasedMailbox
        }
        bounded-deque-based : {
          mailbox-type : Akka.Dispatch.BoundedDequeBasedMailbox
        }
        logger-queue : {
          mailbox-type : Akka.Event.LoggerMailboxType
        }
      }
      debug : {
        receive : off
        autoreceive : off
        lifecycle : off
        fsm : off
        event-stream : off
        unhandled : off
        router-misconfiguration : off
      }
      serializers : {
        json : "Akka.Serialization.NewtonSoftJsonSerializer, Akka"
        bytes : "Akka.Serialization.ByteArraySerializer, Akka"
        akka-containers : "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote"
        akka-misc : "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote"
        primitive : "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote"
        proto : "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote"
        daemon-create : "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote"
        akka-system-msg : "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote"
        akka-cluster : "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster"
        akka-pubsub : "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools"
        hyperion : "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion"
      }
      serialization-bindings : {
        System.Byte[] : bytes
        System.Object : json
        "Akka.Actor.ActorSelectionMessage, Akka" : akka-containers
        "Akka.Remote.DaemonMsgCreate, Akka.Remote" : daemon-create
        "Google.Protobuf.IMessage, Google.Protobuf" : proto
        "Akka.Actor.Identify, Akka" : akka-misc
        "Akka.Actor.ActorIdentity, Akka" : akka-misc
        "Akka.Actor.IActorRef, Akka" : akka-misc
        "Akka.Actor.PoisonPill, Akka" : akka-misc
        "Akka.Actor.Kill, Akka" : akka-misc
        "Akka.Actor.Status+Failure, Akka" : akka-misc
        "Akka.Actor.Status+Success, Akka" : akka-misc
        "Akka.Actor.RemoteScope, Akka" : akka-misc
        "Akka.Routing.FromConfig, Akka" : akka-misc
        "Akka.Routing.DefaultResizer, Akka" : akka-misc
        "Akka.Routing.RoundRobinPool, Akka" : akka-misc
        "Akka.Routing.BroadcastPool, Akka" : akka-misc
        "Akka.Routing.RandomPool, Akka" : akka-misc
        "Akka.Routing.ScatterGatherFirstCompletedPool, Akka" : akka-misc
        "Akka.Routing.TailChoppingPool, Akka" : akka-misc
        "Akka.Routing.ConsistentHashingPool, Akka" : akka-misc
        "Akka.Configuration.Config, Akka" : akka-misc
        "Akka.Remote.RemoteWatcher+Heartbeat, Akka.Remote" : akka-misc
        "Akka.Remote.RemoteWatcher+HeartbeatRsp, Akka.Remote" : akka-misc
        "Akka.Remote.Routing.RemoteRouterConfig, Akka.Remote" : akka-misc
        "Akka.Dispatch.SysMsg.SystemMessage, Akka" : akka-system-msg
        System.String : primitive
        System.Int32 : primitive
        System.Int64 : primitive
        "Akka.Cluster.IClusterMessage, Akka.Cluster" : akka-cluster
        "Akka.Cluster.Routing.ClusterRouterPool, Akka.Cluster" : akka-cluster
        "Akka.Cluster.Tools.PublishSubscribe.IDistributedPubSubMessage, Akka.Cluster.Tools" : akka-pubsub
        "Akka.Cluster.Tools.PublishSubscribe.Internal.SendToOneSubscriber, Akka.Cluster.Tools" : akka-pubsub
        "Akka.IO.Client.ClientMessage, Akka.IO.Client" : hyperion
      }
      serialization-identifiers : {
        "Akka.Serialization.ByteArraySerializer, Akka" : 4
        "Akka.Serialization.NewtonSoftJsonSerializer, Akka" : 1
        "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" : 2
        "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" : 3
        "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" : 6
        "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" : 16
        "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" : 17
        "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" : 22
        "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster" : 5
        "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools" : 9
      }
      serialization-settings : {
        json : {
          use-pooled-string-builder : true
          pooled-string-builder-minsize : 2048
          pooled-string-builder-maxsize : 32768
        }
        primitive : {
          use-legacy-behavior : on
        }
      }
    }
    channel-scheduler : {
      parallelism-min : 4
      parallelism-factor : 1
      parallelism-max : 64
      work-max : 10
      work-interval : 500
      work-step : 2
    }
    scheduler : {
      tick-duration : 10ms
      ticks-per-wheel : 512
      implementation : Akka.Actor.HashedWheelTimerScheduler
      shutdown-timeout : 5s
    }
    io : {
      pinned-dispatcher : {
        type : PinnedDispatcher
        executor : fork-join-executor
      }
      tcp : {
        direct-buffer-pool : {
          class : "Akka.IO.Buffers.DirectBufferPool, Akka"
          buffer-size : 262144
          buffers-per-segment : 500
          initial-segments : 1
          buffer-pool-limit : 1024
        }
        disabled-buffer-pool : {
          class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
          buffer-size : 512
        }
        buffer-pool : akka.io.tcp.disabled-buffer-pool
        max-channels : 256000
        selector-association-retries : 10
        batch-accept-limit : 10
        register-timeout : 5s
        max-received-message-size : unlimited
        trace-logging : off
        selector-dispatcher : akka.io.pinned-dispatcher
        worker-dispatcher : akka.actor.internal-dispatcher
        management-dispatcher : akka.actor.internal-dispatcher
        file-io-dispatcher : akka.actor.default-blocking-io-dispatcher
        file-io-transferTo-limit : 524288
        finish-connect-retries : 5
        windows-connection-abort-workaround-enabled : off
        outgoing-socket-force-ipv4 : false
      }
      udp : {
        direct-buffer-pool : {
          class : "Akka.IO.Buffers.DirectBufferPool, Akka"
          buffer-size : 512
          buffers-per-segment : 500
          initial-segments : 1
          buffer-pool-limit : 1024
        }
        disabled-buffer-pool : {
          class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
          buffer-size : 512
        }
        buffer-pool : akka.io.udp.disabled-buffer-pool
        nr-of-socket-async-event-args : 32
        max-channels : 4096
        select-timeout : infinite
        selector-association-retries : 10
        receive-throughput : 3
        received-message-size-limit : unlimited
        trace-logging : off
        selector-dispatcher : akka.io.pinned-dispatcher
        worker-dispatcher : akka.actor.internal-dispatcher
        management-dispatcher : akka.actor.internal-dispatcher
      }
      udp-connected : {
        direct-buffer-pool : {
          class : "Akka.IO.Buffers.DirectBufferPool, Akka"
          buffer-size : 512
          buffers-per-segment : 500
          initial-segments : 1
          buffer-pool-limit : 1024
        }
        disabled-buffer-pool : {
          class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
          buffer-size : 512
        }
        buffer-pool : akka.io.udp-connected.disabled-buffer-pool
        nr-of-socket-async-event-args : 32
        max-channels : 4096
        select-timeout : infinite
        selector-association-retries : 10
        receive-throughput : 3
        received-message-size-limit : unlimited
        trace-logging : off
        selector-dispatcher : akka.io.pinned-dispatcher
        worker-dispatcher : akka.actor.internal-dispatcher
        management-dispatcher : akka.actor.internal-dispatcher
      }
      dns : {
        dispatcher : akka.actor.internal-dispatcher
        resolver : inet-address
        inet-address : {
          provider-object : Akka.IO.InetAddressDnsProvider
          positive-ttl : 30s
          negative-ttl : 10s
          cache-cleanup-interval : 120s
          use-ipv6 : true
        }
      }
    }
    coordinated-shutdown : {
      default-phase-timeout : "5 s"
      terminate-actor-system : on
      exit-clr : off
      run-by-clr-shutdown-hook : on
      run-by-actor-system-terminate : on
      phases : {
        before-service-unbind : {
        }
        service-unbind : {
          depends-on : [before-service-unbind]
        }
        service-requests-done : {
          depends-on : [service-unbind]
        }
        service-stop : {
          depends-on : [service-requests-done]
        }
        before-cluster-shutdown : {
          depends-on : [service-stop]
        }
        cluster-sharding-shutdown-region : {
          timeout : "10 s"
          depends-on : [before-cluster-shutdown]
        }
        cluster-leave : {
          depends-on : [cluster-sharding-shutdown-region]
        }
        cluster-exiting : {
          timeout : "10 s"
          depends-on : [cluster-leave]
        }
        cluster-exiting-done : {
          depends-on : [cluster-exiting]
        }
        cluster-shutdown : {
          depends-on : [cluster-exiting-done]
        }
        before-actor-system-terminate : {
          depends-on : [cluster-shutdown]
        }
        actor-system-terminate : {
          timeout : "10 s"
          depends-on : [before-actor-system-terminate]
        }
      }
    }
    remote : {
      startup-timeout : "10 s"
      shutdown-timeout : "10 s"
      flush-wait-on-shutdown : "2 s"
      use-passive-connections : on
      backoff-interval : "0.05 s"
      command-ack-timeout : "30 s"
      handshake-timeout : "15 s"
      use-dispatcher : akka.remote.default-remote-dispatcher
      untrusted-mode : off
      trusted-selection-paths : <<unknown value>>
      require-cookie : off
      secure-cookie :
      log-received-messages : off
      log-sent-messages : off
      log-remote-lifecycle-events : on
      log-frame-size-exceeding : off
      log-buffer-size-exceeding : 50000
      transport-failure-detector : {
        implementation-class : Akka.Remote.DeadlineFailureDetector,Akka.Remote
        heartbeat-interval : "4 s"
        acceptable-heartbeat-pause : "120 s"
      }
      watch-failure-detector : {
        implementation-class : Akka.Remote.PhiAccrualFailureDetector,Akka.Remote
        heartbeat-interval : "1 s"
        threshold : 10.0
        max-sample-size : 200
        min-std-deviation : "100 ms"
        acceptable-heartbeat-pause : "10 s"
        unreachable-nodes-reaper-interval : 1s
        expected-response-after : "1 s"
      }
      retry-gate-closed-for : "5 s"
      prune-quarantine-marker-after : "5 d"
      quarantine-after-silence : "2 d"
      system-message-buffer-size : 20000
      system-message-ack-piggyback-timeout : "0.3 s"
      resend-interval : "2 s"
      resend-limit : 200
      initial-system-message-delivery-timeout : "3 m"
      enabled-transports : [akka.remote.dot-netty.tcp]
      adapters : {
        gremlin : Akka.Remote.Transport.FailureInjectorProvider,Akka.Remote
        trttl : Akka.Remote.Transport.ThrottlerProvider,Akka.Remote
      }
      helios : {
        tcp : {
          transport-class : "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote.Transport.Helios"
        }
      }
      dot-netty : {
        tcp : {
          transport-class : Akka.Remote.Transport.DotNetty.TcpTransport,Akka.Remote
          applied-adapters : <<unknown value>>
          transport-protocol : tcp
          byte-order : little-endian
          port : 9011
          public-port : 0
          hostname :
          public-hostname : localhost
          dns-use-ipv6 : false
          enforce-ip-family : false
          enable-ssl : false
          enable-backwards-compatibility : false
          connection-timeout : "15 s"
          batching : {
            enabled : true
            max-pending-writes : 30
          }
          use-dispatcher-for-io :
          write-buffer-high-water-mark : 0b
          write-buffer-low-water-mark : 0b
          send-buffer-size : 6MiB
          receive-buffer-size : 6MiB
          maximum-frame-size : 6MiB
          backlog : 4096
          tcp-nodelay : on
          tcp-keepalive : on
          tcp-reuse-addr : off-for-windows
          server-socket-worker-pool : {
            pool-size-min : 2
            pool-size-factor : 1.0
            pool-size-max : 2
          }
          client-socket-worker-pool : {
            pool-size-min : 2
            pool-size-factor : 1.0
            pool-size-max : 2
          }
          message-frame-size : 6MiB
        }
        udp : {
          transport-protocol : udp
        }
        ssl : {
          certificate : {
            path :
            password :
            use-thumbprint-over-file : false
            thumbprint :
            store-name :
            store-location : current-user
          }
          suppress-validation : false
        }
      }
      gremlin : {
        debug : off
      }
      default-remote-dispatcher : {
        executor : fork-join-executor
        fork-join-executor : {
          parallelism-min : 2
          parallelism-factor : 0.5
          parallelism-max : 16
        }
        channel-executor : {
          priority : high
        }
      }
      backoff-remote-dispatcher : {
        executor : fork-join-executor
        fork-join-executor : {
          parallelism-min : 2
          parallelism-max : 2
        }
        channel-executor : {
          priority : low
        }
      }
    }
    cluster : {
      seed-nodes : ["akka.tcp://ClusterSystem@localhost:9011","akka.tcp://ClusterSystem@localhost:9012"]
      seed-node-timeout : 5s
      retry-unsuccessful-join-after : 10s
      shutdown-after-unsuccessful-join-seed-nodes : 60s
      auto-down-unreachable-after : off
      down-removal-margin : 20s
      downing-provider-class : "Akka.Cluster.SplitBrainResolver, Akka.Cluster"
      allow-weakly-up-members : on
      roles : [receptionist]
      app-version : assembly-version
      run-coordinated-shutdown-when-down : on
      role : {
      }
      min-nr-of-members : 1
      log-info : on
      log-info-verbose : off
      periodic-tasks-initial-delay : 1s
      gossip-interval : 1s
      gossip-time-to-live : 2s
      leader-actions-interval : 1s
      unreachable-nodes-reaper-interval : 1s
      publish-stats-interval : off
      use-dispatcher :
      gossip-different-view-probability : 0.8
      reduce-gossip-different-view-probability : 400
      failure-detector : {
        implementation-class : "Akka.Remote.PhiAccrualFailureDetector, Akka.Remote"
        heartbeat-interval : "1 s"
        threshold : 8.0
        max-sample-size : 1000
        min-std-deviation : "100 ms"
        acceptable-heartbeat-pause : "3 s"
        monitored-by-nr-of-members : 9
        expected-response-after : "1 s"
      }
      scheduler : {
        tick-duration : 33ms
        ticks-per-wheel : 512
      }
      debug : {
        verbose-heartbeat-logging : off
        verbose-receive-gossip-logging : off
      }
      split-brain-resolver : {
        active-strategy : keep-majority
        stable-after : 20s
        down-all-when-unstable : on
        static-quorum : {
          quorum-size : undefined
          role :
        }
        keep-majority : {
          role : receptionist
        }
        keep-oldest : {
          down-if-alone : on
          role :
        }
        lease-majority : {
          lease-implementation :
          lease-name :
          acquire-lease-delay-for-minority : 2s
          release-after : 40s
          role :
        }
        keep-referee : {
          address :
          down-all-if-less-than-nodes : 1
        }
      }
      pub-sub : {
        name : distributedPubSubMediator
        role :
        routing-logic : random
        gossip-interval : 1s
        removed-time-to-live : 120s
        max-delta-elements : 3000
        send-to-dead-letters-when-no-subscribers : on
        use-dispatcher :
      }
    }
  }

@Aaronontheweb
Copy link
Member

Not sure why this is an issue with your application, but I found the problem:

serialization-identifiers : {
"Akka.Serialization.ByteArraySerializer, Akka" : 4
"Akka.Serialization.NewtonSoftJsonSerializer, Akka" : 1
"Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" : 2
"Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" : 3
"Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" : 6
"Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" : 16
"Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" : 17
"Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" : 22
"Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster" : 5
"Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools" : 9
}

That section is missing the Hyperion serializer definition. If you add the following to your HOCON:

akka.actor.serialization-identifiers{
  "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion" = -5
}

Then that work-around should alleviate the issue.

@ayooyeyipo
Copy link
Author

Thank you for your support, I try it and let you know the outcome

@Aaronontheweb
Copy link
Member

@ayooyeyipo did my work-around help solve the issue?

@ayooyeyipo
Copy link
Author

I am trying it out in our staging environment, I will let know the outcome when I finished, maybe by tomorrow

@ayooyeyipo
Copy link
Author

I have tired it, the work around did not solve the issue.

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 18, 2023

Below is the akka configuration from akka.log-config-on-start = on

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 18, 2023

   akka : {
     version : "0.0.1 Akka"
     home : 
     loggers : ["Akka.Logger.Serilog.SerilogLogger, Akka.Logger.Serilog"]
     loggers-dispatcher : akka.actor.default-dispatcher
     logger-startup-timeout : 5s
     logger-async-start : false
     loglevel : INFO
     suppress-json-serializer-warning : on
     stdout-loglevel : INFO
     stdout-logger-class : Akka.Event.StandardOutLogger
     log-config-on-start : on
     log-dead-letters : 10
     log-dead-letters-during-shutdown : off
     log-dead-letters-suspend-duration : "5 minutes"
     extensions : [Akka.Cluster.Tools.PublishSubscribe.DistributedPubSubExtensionProvider,Akka.Cluster.Tools]
     daemonic : off
     actor : {
       provider : cluster
       guardian-supervisor-strategy : Akka.Actor.DefaultSupervisorStrategy
       creation-timeout : 20s
       reaper-interval : 5
       serialize-messages : off
       serialize-creators : off
       unstarted-push-timeout : 10s
       ask-timeout : infinite
       telemetry : {
         enabled : false
       }
       typed : {
         timeout : 5
       }
       inbox : {
         inbox-size : 1000
         default-timeout : 5s
       }
       router : {
         type-mapping : {
           from-code : Akka.Routing.NoRouter
           round-robin-pool : Akka.Routing.RoundRobinPool
           round-robin-group : Akka.Routing.RoundRobinGroup
           random-pool : Akka.Routing.RandomPool
           random-group : Akka.Routing.RandomGroup
           smallest-mailbox-pool : Akka.Routing.SmallestMailboxPool
           broadcast-pool : Akka.Routing.BroadcastPool
           broadcast-group : Akka.Routing.BroadcastGroup
           scatter-gather-pool : Akka.Routing.ScatterGatherFirstCompletedPool
           scatter-gather-group : Akka.Routing.ScatterGatherFirstCompletedGroup
           consistent-hashing-pool : Akka.Routing.ConsistentHashingPool
           consistent-hashing-group : Akka.Routing.ConsistentHashingGroup
           tail-chopping-pool : Akka.Routing.TailChoppingPool
           tail-chopping-group : Akka.Routing.TailChoppingGroup
           cluster-metrics-adaptive-pool : "Akka.Cluster.Metrics.AdaptiveLoadBalancingPool, Akka.Cluster.Metrics"
           cluster-metrics-adaptive-group : "Akka.Cluster.Metrics.AdaptiveLoadBalancingGroup, Akka.Cluster.Metrics"
         }
       }
       deployment : {
         default : {
           dispatcher : 
           mailbox : 
           router : from-code
           nr-of-instances : 1
           within : "5 s"
           virtual-nodes-factor : 10
           routees : {
             paths : <<unknown value>>
           }
           resizer : {
             enabled : off
             lower-bound : 1
             upper-bound : 10
             pressure-threshold : 1
             rampup-rate : 0.2
             backoff-threshold : 0.3
             backoff-rate : 0.1
             messages-per-resize : 10
           }
           remote : 
           target : {
             nodes : <<unknown value>>
           }
           metrics-selector : mix
           cluster : {
             enabled : off
             max-nr-of-instances-per-node : 1
             max-total-nr-of-instances : 10000
             allow-local-routees : on
             use-role : 
           }
         }
       }
       synchronized-dispatcher : {
         type : SynchronizedDispatcher
         executor : current-context-executor
         throughput : 10
       }
       task-dispatcher : {
         type : TaskDispatcher
         executor : task-executor
         throughput : 30
       }
       default-fork-join-dispatcher : {
         type : ForkJoinDispatcher
         executor : fork-join-executor
         throughput : 30
         dedicated-thread-pool : {
           thread-count : 3
           threadtype : background
         }
       }
       default-dispatcher : {
         type : Dispatcher
         executor : default-executor
         default-executor : {
         }
         thread-pool-executor : {
         }
         fork-join-executor : {
           parallelism-min : 8
           parallelism-factor : 1.0
           parallelism-max : 64
           task-peeking-mode : FIFO
         }
         current-context-executor : {
         }
         shutdown-timeout : 1s
         throughput : 30
         throughput-deadline-time : 0ms
         attempt-teamwork : on
         mailbox-requirement : 
       }
       internal-dispatcher : {
         type : Dispatcher
         executor : fork-join-executor
         throughput : 5
         fork-join-executor : {
           parallelism-min : 4
           parallelism-factor : 1.0
           parallelism-max : 64
         }
         channel-executor : {
           priority : high
         }
       }
       default-blocking-io-dispatcher : {
         type : Dispatcher
         executor : thread-pool-executor
         throughput : 1
       }
       default-mailbox : {
         mailbox-type : Akka.Dispatch.UnboundedMailbox
         mailbox-capacity : 1000
         mailbox-push-timeout-time : 10s
         stash-capacity : -1
       }
       mailbox : {
         requirements : {
           Akka.Dispatch.IUnboundedMessageQueueSemantics : akka.actor.mailbox.unbounded-queue-based
           Akka.Dispatch.IBoundedMessageQueueSemantics : akka.actor.mailbox.bounded-queue-based
           Akka.Dispatch.IDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
           Akka.Dispatch.IUnboundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
           Akka.Dispatch.IBoundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.bounded-deque-based
           Akka.Dispatch.IMultipleConsumerSemantics : akka.actor.mailbox.unbounded-queue-based
           Akka.Event.ILoggerMessageQueueSemantics : akka.actor.mailbox.logger-queue
         }
         unbounded-queue-based : {
           mailbox-type : Akka.Dispatch.UnboundedMailbox
         }
         bounded-queue-based : {
           mailbox-type : Akka.Dispatch.BoundedMailbox
         }
         unbounded-deque-based : {
           mailbox-type : Akka.Dispatch.UnboundedDequeBasedMailbox
         }
         bounded-deque-based : {
           mailbox-type : Akka.Dispatch.BoundedDequeBasedMailbox
         }
         logger-queue : {
           mailbox-type : Akka.Event.LoggerMailboxType
         }
       }
       debug : {
         receive : off
         autoreceive : off
         lifecycle : off
         fsm : off
         event-stream : off
         unhandled : off
         router-misconfiguration : off
       }
       serializers : {
         json : "Akka.Serialization.NewtonSoftJsonSerializer, Akka"
         bytes : "Akka.Serialization.ByteArraySerializer, Akka"
         akka-containers : "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote"
         akka-misc : "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote"
         primitive : "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote"
         proto : "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote"
         daemon-create : "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote"
         akka-system-msg : "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote"
         akka-cluster : "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster"
         akka-pubsub : "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools"
         hyperion : "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion"
       }
       serialization-bindings : {
         System.Byte[] : bytes
         System.Object : json
         "Akka.Actor.ActorSelectionMessage, Akka" : akka-containers
         "Akka.Remote.DaemonMsgCreate, Akka.Remote" : daemon-create
         "Google.Protobuf.IMessage, Google.Protobuf" : proto
         "Akka.Actor.Identify, Akka" : akka-misc
         "Akka.Actor.ActorIdentity, Akka" : akka-misc
         "Akka.Actor.IActorRef, Akka" : akka-misc
         "Akka.Actor.PoisonPill, Akka" : akka-misc
         "Akka.Actor.Kill, Akka" : akka-misc
         "Akka.Actor.Status+Failure, Akka" : akka-misc
         "Akka.Actor.Status+Success, Akka" : akka-misc
         "Akka.Actor.RemoteScope, Akka" : akka-misc
         "Akka.Routing.FromConfig, Akka" : akka-misc
         "Akka.Routing.DefaultResizer, Akka" : akka-misc
         "Akka.Routing.RoundRobinPool, Akka" : akka-misc
         "Akka.Routing.BroadcastPool, Akka" : akka-misc
         "Akka.Routing.RandomPool, Akka" : akka-misc
         "Akka.Routing.ScatterGatherFirstCompletedPool, Akka" : akka-misc
         "Akka.Routing.TailChoppingPool, Akka" : akka-misc
         "Akka.Routing.ConsistentHashingPool, Akka" : akka-misc
         "Akka.Configuration.Config, Akka" : akka-misc
         "Akka.Remote.RemoteWatcher+Heartbeat, Akka.Remote" : akka-misc
         "Akka.Remote.RemoteWatcher+HeartbeatRsp, Akka.Remote" : akka-misc
         "Akka.Remote.Routing.RemoteRouterConfig, Akka.Remote" : akka-misc
         "Akka.Dispatch.SysMsg.SystemMessage, Akka" : akka-system-msg
         System.String : primitive
         System.Int32 : primitive
         System.Int64 : primitive
         "Akka.Cluster.IClusterMessage, Akka.Cluster" : akka-cluster
         "Akka.Cluster.Routing.ClusterRouterPool, Akka.Cluster" : akka-cluster
         "Akka.Cluster.Tools.PublishSubscribe.IDistributedPubSubMessage, Akka.Cluster.Tools" : akka-pubsub
         "Akka.Cluster.Tools.PublishSubscribe.Internal.SendToOneSubscriber, Akka.Cluster.Tools" : akka-pubsub
         "Akka.IO.Client.ClientMessage, Akka.IO.Client" : hyperion
       }
       serialization-identifiers : {
         "Akka.Serialization.ByteArraySerializer, Akka" : 4
         "Akka.Serialization.NewtonSoftJsonSerializer, Akka" : 1
         "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" : 2
         "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" : 3
         "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" : 6
         "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" : 16
         "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" : 17
         "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" : 22
         "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster" : 5
         "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools" : 9
         "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion" : -5
       }
       serialization-settings : {
         json : {
           use-pooled-string-builder : true
           pooled-string-builder-minsize : 2048
           pooled-string-builder-maxsize : 32768
         }
         primitive : {
           use-legacy-behavior : on
         }
       }
     }
     channel-scheduler : {
       parallelism-min : 4
       parallelism-factor : 1
       parallelism-max : 64
       work-max : 10
       work-interval : 500
       work-step : 2
     }
     scheduler : {
       tick-duration : 10ms
       ticks-per-wheel : 512
       implementation : Akka.Actor.HashedWheelTimerScheduler
       shutdown-timeout : 5s
     }
     io : {
       pinned-dispatcher : {
         type : PinnedDispatcher
         executor : fork-join-executor
       }
       tcp : {
         direct-buffer-pool : {
           class : "Akka.IO.Buffers.DirectBufferPool, Akka"
           buffer-size : 262144
           buffers-per-segment : 500
           initial-segments : 1
           buffer-pool-limit : 1024
         }
         disabled-buffer-pool : {
           class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
           buffer-size : 512
         }
         buffer-pool : akka.io.tcp.disabled-buffer-pool
         max-channels : 256000
         selector-association-retries : 10
         batch-accept-limit : 10
         register-timeout : 5s
         max-received-message-size : unlimited
         trace-logging : off
         selector-dispatcher : akka.io.pinned-dispatcher
         worker-dispatcher : akka.actor.internal-dispatcher
         management-dispatcher : akka.actor.internal-dispatcher
         file-io-dispatcher : akka.actor.default-blocking-io-dispatcher
         file-io-transferTo-limit : 524288
         finish-connect-retries : 5
         windows-connection-abort-workaround-enabled : off
         outgoing-socket-force-ipv4 : false
       }
       udp : {
         direct-buffer-pool : {
           class : "Akka.IO.Buffers.DirectBufferPool, Akka"
           buffer-size : 512
           buffers-per-segment : 500
           initial-segments : 1
           buffer-pool-limit : 1024
         }
         disabled-buffer-pool : {
           class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
           buffer-size : 512
         }
         buffer-pool : akka.io.udp.disabled-buffer-pool
         nr-of-socket-async-event-args : 32
         max-channels : 4096
         select-timeout : infinite
         selector-association-retries : 10
         receive-throughput : 3
         received-message-size-limit : unlimited
         trace-logging : off
         selector-dispatcher : akka.io.pinned-dispatcher
         worker-dispatcher : akka.actor.internal-dispatcher
         management-dispatcher : akka.actor.internal-dispatcher
       }
       udp-connected : {
         direct-buffer-pool : {
           class : "Akka.IO.Buffers.DirectBufferPool, Akka"
           buffer-size : 512
           buffers-per-segment : 500
           initial-segments : 1
           buffer-pool-limit : 1024
         }
         disabled-buffer-pool : {
           class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
           buffer-size : 512
         }
         buffer-pool : akka.io.udp-connected.disabled-buffer-pool
         nr-of-socket-async-event-args : 32
         max-channels : 4096
         select-timeout : infinite
         selector-association-retries : 10
         receive-throughput : 3
         received-message-size-limit : unlimited
         trace-logging : off
         selector-dispatcher : akka.io.pinned-dispatcher
         worker-dispatcher : akka.actor.internal-dispatcher
         management-dispatcher : akka.actor.internal-dispatcher
       }
       dns : {
         dispatcher : akka.actor.internal-dispatcher
         resolver : inet-address
         inet-address : {
           provider-object : Akka.IO.InetAddressDnsProvider
           positive-ttl : 30s
           negative-ttl : 10s
           cache-cleanup-interval : 120s
           use-ipv6 : true
         }
       }
     }
     coordinated-shutdown : {
       default-phase-timeout : "5 s"
       terminate-actor-system : on
       exit-clr : off
       run-by-clr-shutdown-hook : on
       run-by-actor-system-terminate : on
       phases : {
         before-service-unbind : {
         }
         service-unbind : {
           depends-on : [before-service-unbind]
         }
         service-requests-done : {
           depends-on : [service-unbind]
         }
         service-stop : {
           depends-on : [service-requests-done]
         }
         before-cluster-shutdown : {
           depends-on : [service-stop]
         }
         cluster-sharding-shutdown-region : {
           timeout : "10 s"
           depends-on : [before-cluster-shutdown]
         }
         cluster-leave : {
           depends-on : [cluster-sharding-shutdown-region]
         }
         cluster-exiting : {
           timeout : "10 s"
           depends-on : [cluster-leave]
         }
         cluster-exiting-done : {
           depends-on : [cluster-exiting]
         }
         cluster-shutdown : {
           depends-on : [cluster-exiting-done]
         }
         before-actor-system-terminate : {
           depends-on : [cluster-shutdown]
         }
         actor-system-terminate : {
           timeout : "10 s"
           depends-on : [before-actor-system-terminate]
         }
       }
     }
     remote : {
       startup-timeout : "10 s"
       shutdown-timeout : "10 s"
       flush-wait-on-shutdown : "2 s"
       use-passive-connections : on
       backoff-interval : "0.05 s"
       command-ack-timeout : "30 s"
       handshake-timeout : "15 s"
       use-dispatcher : akka.remote.default-remote-dispatcher
       untrusted-mode : off
       trusted-selection-paths : <<unknown value>>
       require-cookie : off
       secure-cookie : 
       log-received-messages : off
       log-sent-messages : off
       log-remote-lifecycle-events : on
       log-frame-size-exceeding : off
       log-buffer-size-exceeding : 50000
       transport-failure-detector : {
         implementation-class : Akka.Remote.DeadlineFailureDetector,Akka.Remote
         heartbeat-interval : "4 s"
         acceptable-heartbeat-pause : "120 s"
       }
       watch-failure-detector : {
         implementation-class : Akka.Remote.PhiAccrualFailureDetector,Akka.Remote
         heartbeat-interval : "1 s"
         threshold : 10.0
         max-sample-size : 200
         min-std-deviation : "100 ms"
         acceptable-heartbeat-pause : "10 s"
         unreachable-nodes-reaper-interval : 1s
         expected-response-after : "1 s"
       }
       retry-gate-closed-for : "5 s"
       prune-quarantine-marker-after : "5 d"
       quarantine-after-silence : "2 d"
       system-message-buffer-size : 20000
       system-message-ack-piggyback-timeout : "0.3 s"
       resend-interval : "2 s"
       resend-limit : 200
       initial-system-message-delivery-timeout : "3 m"
       enabled-transports : [akka.remote.dot-netty.tcp]
       adapters : {
         gremlin : Akka.Remote.Transport.FailureInjectorProvider,Akka.Remote
         trttl : Akka.Remote.Transport.ThrottlerProvider,Akka.Remote
       }
       helios : {
         tcp : {
           transport-class : "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote.Transport.Helios"
         }
       }
       dot-netty : {
         tcp : {
           transport-class : Akka.Remote.Transport.DotNetty.TcpTransport,Akka.Remote
           applied-adapters : <<unknown value>>
           transport-protocol : tcp
           byte-order : little-endian
           port : 9011
           public-port : 0
           hostname : 
           public-hostname : localhost
           dns-use-ipv6 : false
           enforce-ip-family : false
           enable-ssl : false
           enable-backwards-compatibility : false
           connection-timeout : "15 s"
           batching : {
             enabled : true
             max-pending-writes : 30
           }
           use-dispatcher-for-io : 
           write-buffer-high-water-mark : 0b
           write-buffer-low-water-mark : 0b
           send-buffer-size : 6MiB
           receive-buffer-size : 6MiB
           maximum-frame-size : 6MiB
           backlog : 4096
           tcp-nodelay : on
           tcp-keepalive : on
           tcp-reuse-addr : off-for-windows
           server-socket-worker-pool : {
             pool-size-min : 2
             pool-size-factor : 1.0
             pool-size-max : 2
           }
           client-socket-worker-pool : {
             pool-size-min : 2
             pool-size-factor : 1.0
             pool-size-max : 2
           }
           message-frame-size : 6MiB
         }
         udp : {
           transport-protocol : udp
         }
         ssl : {
           certificate : {
             path : 
             password : 
             use-thumbprint-over-file : false
             thumbprint : 
             store-name : 
             store-location : current-user
           }
           suppress-validation : false
         }
       }
       gremlin : {
         debug : off
       }
       default-remote-dispatcher : {
         executor : fork-join-executor
         fork-join-executor : {
           parallelism-min : 2
           parallelism-factor : 0.5
           parallelism-max : 16
         }
         channel-executor : {
           priority : high
         }
       }
       backoff-remote-dispatcher : {
         executor : fork-join-executor
         fork-join-executor : {
           parallelism-min : 2
           parallelism-max : 2
         }
         channel-executor : {
           priority : low
         }
       }
     }
     cluster : {
       seed-nodes : ["akka.tcp://ClusterSystem@localhost:9011","akka.tcp://ClusterSystem@localhost:9011"]
       seed-node-timeout : 5s
       retry-unsuccessful-join-after : 10s
       shutdown-after-unsuccessful-join-seed-nodes : 60s
       auto-down-unreachable-after : off
       down-removal-margin : 20s
       downing-provider-class : "Akka.Cluster.SplitBrainResolver, Akka.Cluster"
       allow-weakly-up-members : on
       roles : [receptionist]
       app-version : assembly-version
       run-coordinated-shutdown-when-down : on
       role : {
       }
       min-nr-of-members : 1
       log-info : on
       log-info-verbose : off
       periodic-tasks-initial-delay : 1s
       gossip-interval : 1s
       gossip-time-to-live : 2s
       leader-actions-interval : 1s
       unreachable-nodes-reaper-interval : 1s
       publish-stats-interval : off
       use-dispatcher : 
       gossip-different-view-probability : 0.8
       reduce-gossip-different-view-probability : 400
       failure-detector : {
         implementation-class : "Akka.Remote.PhiAccrualFailureDetector, Akka.Remote"
         heartbeat-interval : "1 s"
         threshold : 8.0
         max-sample-size : 1000
         min-std-deviation : "100 ms"
         acceptable-heartbeat-pause : "3 s"
         monitored-by-nr-of-members : 9
         expected-response-after : "1 s"
       }
       scheduler : {
         tick-duration : 33ms
         ticks-per-wheel : 512
       }
       debug : {
         verbose-heartbeat-logging : off
         verbose-receive-gossip-logging : off
       }
       split-brain-resolver : {
         active-strategy : keep-majority
         stable-after : 20s
         down-all-when-unstable : on
         static-quorum : {
           quorum-size : undefined
           role : 
         }
         keep-majority : {
           role : receptionist
         }
         keep-oldest : {
           down-if-alone : on
           role : 
         }
         lease-majority : {
           lease-implementation : 
           lease-name : 
           acquire-lease-delay-for-minority : 2s
           release-after : 40s
           role : 
         }
         keep-referee : {
           address : 
           down-all-if-less-than-nodes : 1
         }
       }
       pub-sub : {
         name : distributedPubSubMediator
         role : 
         routing-logic : random
         gossip-interval : 1s
         removed-time-to-live : 120s
         max-delta-elements : 3000
         send-to-dead-letters-when-no-subscribers : on
         use-dispatcher : 
       }
     }
   }

@ayooyeyipo
Copy link
Author

The exception:
Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array.
3: Could not find any internal Akka.NET serializer with Id [-5]. Please create an issue in our GitHub at [https://github.com/akkadotnet/akka.net].
@l: Warning
@mt: Deserialization failed for message with serializer id [-5] and manifest [:]. Transient association error (association remains live). Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]. Please create an issue in our GitHub at [https://github.com/akkadotnet/akka.net]
@t: 2023-05-18T08:41:38.0818336Z
@x: System.Runtime.Serialization.SerializationException: Failed to deserialize object of type [Akka.Actor.Status+Failure] from the stream. Cause: Index was outside the bounds of the array.
---> System.IndexOutOfRangeException: Index was outside the bounds of the array.
at lambda_method(Closure , Stream , DeserializerSession )
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)
--- End of inner exception stack trace ---
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)
at Hyperion.Serializer.Deserialize[T](Stream stream)
at Akka.Serialization.HyperionSerializer.FromBinary(Byte[] bytes, Type type)
at Akka.Serialization.Serialization.Deserialize(Byte[] bytes, Int32 serializerId, String manifest)
at Akka.Remote.MessageSerializer.Deserialize(ExtendedActorSystem system, Payload messageProtocol)
at Akka.Remote.DefaultMessageDispatcher.Dispatch(IInternalActorRef recipient, Address recipientAddress, Payload message, IActorRef senderOption)
at Akka.Remote.EndpointReader.b__11_0(InboundPayload inbound)

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 18, 2023

This only happens when the copy application is running on more than one machine in the same cluster.

@Aaronontheweb
Copy link
Member

serialization-identifiers : {
"Akka.Serialization.ByteArraySerializer, Akka" : 4
"Akka.Serialization.NewtonSoftJsonSerializer, Akka" : 1
"Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" : 2
"Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" : 3
"Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" : 6
"Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" : 16
"Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" : 17
"Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" : 22
"Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster" : 5
"Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools" : 9
"Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion" : -5
}

Those settings are correct, so maybe that binding wasn't the issue (although the error message indicates as such) - looks like Hyperion really is being used here:

stream. Cause: Index was outside the bounds of the array.
---> System.IndexOutOfRangeException: Index was outside the bounds of the array.
at lambda_method(Closure , Stream , DeserializerSession )
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)
--- End of inner exception stack trace ---
at Hyperion.ValueSerializers.ObjectSerializer.ReadValue(Stream stream, DeserializerSession session)

@ayooyeyipo are you using a blend of .NET Framework AND .NET Core inside your network?

@ayooyeyipo
Copy link
Author

Yes

@ayooyeyipo
Copy link
Author

The request is coming from .NET framework application which is not part of the cluster to this Service (.NET Core, F#, Giraffe) and from there it is forwarded to another application in the cluster.

@ayooyeyipo
Copy link
Author

It was working fine before the upgrade

@Aaronontheweb
Copy link
Member

Check 1 - Do This First

Are you using the same version of Hyperion on all nodes? Because https://github.com/akkadotnet/Hyperion/releases/tag/0.10.0 introduced significant changes to how x-plat serialization works between .NET and .NET Framework in order to standardize differences between namespaces for primitive types. If you're running separate versions on one but not the other, you'll have this problem.

Check 2

If you are using the same versions of Hyperion in all applications and are still having this problem, you can disable the X-PLAT behavior we introduced in 0.10.0 ( akkadotnet/Hyperion#208) without downgrading

To restore the older behavior, you might need to use the HyperionSerializerSetup class and specify an empty set of namespace overrides:

var setup = HyperionSerializerSetup.Create(preserveObjectReferences: true, versionTolerance:true, 
	knownTypesProvider: null, 
	packageNameOverrides: new List<Func<string, string>>()); // empty package overrides list
	
var myOtherHocon = ConfigurationFactory.ParseString("akka.actor.provider = remote"); // rest of HOCON

var bootstrapSetup = BootstrapSetup.Create().WithConfig(myOtherHocon).And(setup);
var actorSystem = ActorSystem.Create("MySys", bootstrapSetup);

This should disable that new feature introduced in Hyperion 0.10.0 - am I correct about that @Arkatufus ?

@ayooyeyipo
Copy link
Author

ayooyeyipo commented May 18, 2023

Can I downgrade only Hyperion and Akka.Serialization.Hyperion, leave the other packages?

@Aaronontheweb
Copy link
Member

Can I downgrade only Hyperion and Akka.Serialization.Hyperion, leave the other packages?

I think so - the Akka.Serialization.Hyperion package doesn't use much of the Akka.NET APIs (just serialization, which we haven't changed.)

@Aaronontheweb
Copy link
Member

Can I downgrade only Hyperion and Akka.Serialization.Hyperion, leave the other packages?

@ayooyeyipo please let us know if you do this and it works successfully.

@ayooyeyipo
Copy link
Author

Can I downgrade only Hyperion and Akka.Serialization.Hyperion, leave the other packages?

@ayooyeyipo please let us know if you do this and it works successfully.

Ok

@ayooyeyipo
Copy link
Author

ayooyeyipo commented Jun 26, 2023

I downgraded to the Hyperion version before the upgrade which was 0.9.12 and `Akka.Serialization.Hyperion (1.3.14-beta).
The service is returning this new error message:

Index was outside the bounds of the array.
Could not find any internal Akka.NET serializer with Id [-5]. Please create an issue in our GitHub at [https://github.com/akkadotnet/akka.net].
@l: Warning
@mt: Deserialization failed for message with serializer id [-5] and manifest [:]. Transient association error (association remains live). Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]. Please create an issue in our GitHub at [https://github.com/akkadotnet/akka.net]
@t: 2023-06-26T08:22:17.8359641Z
@x: System.IndexOutOfRangeException: Index was outside the bounds of the array.
at lambda_method(Closure , Stream , DeserializerSession )
at Hyperion.Serializer.Deserialize[T](Stream stream)
at Akka.Serialization.HyperionSerializer.FromBinary(Byte[] bytes, Type type)
at Akka.Serialization.Serialization.Deserialize(Byte[] bytes, Int32 serializerId, String manifest)
at Akka.Remote.MessageSerializer.Deserialize(ExtendedActorSystem system, Payload messageProtocol)
at Akka.Remote.DefaultMessageDispatcher.Dispatch(IInternalActorRef recipient, Address recipientAddress, Payload message, IActorRef senderOption)
at Akka.Remote.EndpointReader.b__11_0(InboundPayload inbound)

@ayooyeyipo
Copy link
Author

ayooyeyipo commented Jun 26, 2023

akka : {
                         version : "0.0.1 Akka"
                         home : 
                         loggers : ["Akka.Logger.Serilog.SerilogLogger, Akka.Logger.Serilog"]
                         loggers-dispatcher : akka.actor.default-dispatcher
                         logger-startup-timeout : 5s
                         logger-async-start : false
                         loglevel : INFO
                         suppress-json-serializer-warning : on
                         stdout-loglevel : INFO
                         stdout-logger-class : Akka.Event.StandardOutLogger
                         log-config-on-start : on
                         log-dead-letters : 10
                         log-dead-letters-during-shutdown : off
                         log-dead-letters-suspend-duration : "5 minutes"
                         extensions : [Akka.Cluster.Tools.PublishSubscribe.DistributedPubSubExtensionProvider,Akka.Cluster.Tools]
                         daemonic : off
                         actor : {
                           provider : cluster
                           guardian-supervisor-strategy : Akka.Actor.DefaultSupervisorStrategy
                           creation-timeout : 20s
                           reaper-interval : 5
                           serialize-messages : off
                           serialize-creators : off
                           unstarted-push-timeout : 10s
                           ask-timeout : infinite
                           telemetry : {
                             enabled : false
                           }
                           typed : {
                             timeout : 5
                           }
                           inbox : {
                             inbox-size : 1000
                             default-timeout : 5s
                           }
                           router : {
                             type-mapping : {
                               from-code : Akka.Routing.NoRouter
                               round-robin-pool : Akka.Routing.RoundRobinPool
                               round-robin-group : Akka.Routing.RoundRobinGroup
                               random-pool : Akka.Routing.RandomPool
                               random-group : Akka.Routing.RandomGroup
                               smallest-mailbox-pool : Akka.Routing.SmallestMailboxPool
                               broadcast-pool : Akka.Routing.BroadcastPool
                               broadcast-group : Akka.Routing.BroadcastGroup
                               scatter-gather-pool : Akka.Routing.ScatterGatherFirstCompletedPool
                               scatter-gather-group : Akka.Routing.ScatterGatherFirstCompletedGroup
                               consistent-hashing-pool : Akka.Routing.ConsistentHashingPool
                               consistent-hashing-group : Akka.Routing.ConsistentHashingGroup
                               tail-chopping-pool : Akka.Routing.TailChoppingPool
                               tail-chopping-group : Akka.Routing.TailChoppingGroup
                               cluster-metrics-adaptive-pool : "Akka.Cluster.Metrics.AdaptiveLoadBalancingPool, Akka.Cluster.Metrics"
                               cluster-metrics-adaptive-group : "Akka.Cluster.Metrics.AdaptiveLoadBalancingGroup, Akka.Cluster.Metrics"
                             }
                           }
                           deployment : {
                             default : {
                               dispatcher : 
                               mailbox : 
                               router : from-code
                               nr-of-instances : 1
                               within : "5 s"
                               virtual-nodes-factor : 10
                               routees : {
                                 paths : <<unknown value>>
                               }
                               resizer : {
                                 enabled : off
                                 lower-bound : 1
                                 upper-bound : 10
                                 pressure-threshold : 1
                                 rampup-rate : 0.2
                                 backoff-threshold : 0.3
                                 backoff-rate : 0.1
                                 messages-per-resize : 10
                               }
                               remote : 
                               target : {
                                 nodes : <<unknown value>>
                               }
                               metrics-selector : mix
                               cluster : {
                                 enabled : off
                                 max-nr-of-instances-per-node : 1
                                 max-total-nr-of-instances : 10000
                                 allow-local-routees : on
                                 use-role : 
                               }
                             }
                           }
                           synchronized-dispatcher : {
                             type : SynchronizedDispatcher
                             executor : current-context-executor
                             throughput : 10
                           }
                           task-dispatcher : {
                             type : TaskDispatcher
                             executor : task-executor
                             throughput : 30
                           }
                           default-fork-join-dispatcher : {
                             type : ForkJoinDispatcher
                             executor : fork-join-executor
                             throughput : 30
                             dedicated-thread-pool : {
                               thread-count : 3
                               threadtype : background
                             }
                           }
                           default-dispatcher : {
                             type : Dispatcher
                             executor : default-executor
                             default-executor : {
                             }
                             thread-pool-executor : {
                             }
                             fork-join-executor : {
                               parallelism-min : 8
                               parallelism-factor : 1.0
                               parallelism-max : 64
                               task-peeking-mode : FIFO
                             }
                             current-context-executor : {
                             }
                             shutdown-timeout : 1s
                             throughput : 30
                             throughput-deadline-time : 0ms
                             attempt-teamwork : on
                             mailbox-requirement : 
                           }
                           internal-dispatcher : {
                             type : Dispatcher
                             executor : fork-join-executor
                             throughput : 5
                             fork-join-executor : {
                               parallelism-min : 4
                               parallelism-factor : 1.0
                               parallelism-max : 64
                             }
                             channel-executor : {
                               priority : high
                             }
                           }
                           default-blocking-io-dispatcher : {
                             type : Dispatcher
                             executor : thread-pool-executor
                             throughput : 1
                           }
                           default-mailbox : {
                             mailbox-type : Akka.Dispatch.UnboundedMailbox
                             mailbox-capacity : 1000
                             mailbox-push-timeout-time : 10s
                             stash-capacity : -1
                           }
                           mailbox : {
                             requirements : {
                               Akka.Dispatch.IUnboundedMessageQueueSemantics : akka.actor.mailbox.unbounded-queue-based
                               Akka.Dispatch.IBoundedMessageQueueSemantics : akka.actor.mailbox.bounded-queue-based
                               Akka.Dispatch.IDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
                               Akka.Dispatch.IUnboundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.unbounded-deque-based
                               Akka.Dispatch.IBoundedDequeBasedMessageQueueSemantics : akka.actor.mailbox.bounded-deque-based
                               Akka.Dispatch.IMultipleConsumerSemantics : akka.actor.mailbox.unbounded-queue-based
                               Akka.Event.ILoggerMessageQueueSemantics : akka.actor.mailbox.logger-queue
                             }
                             unbounded-queue-based : {
                               mailbox-type : Akka.Dispatch.UnboundedMailbox
                             }
                             bounded-queue-based : {
                               mailbox-type : Akka.Dispatch.BoundedMailbox
                             }
                             unbounded-deque-based : {
                               mailbox-type : Akka.Dispatch.UnboundedDequeBasedMailbox
                             }
                             bounded-deque-based : {
                               mailbox-type : Akka.Dispatch.BoundedDequeBasedMailbox
                             }
                             logger-queue : {
                               mailbox-type : Akka.Event.LoggerMailboxType
                             }
                           }
                           debug : {
                             receive : off
                             autoreceive : off
                             lifecycle : off
                             fsm : off
                             event-stream : off
                             unhandled : off
                             router-misconfiguration : off
                           }
                           serializers : {
                             json : "Akka.Serialization.NewtonSoftJsonSerializer, Akka"
                             bytes : "Akka.Serialization.ByteArraySerializer, Akka"
                             akka-containers : "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote"
                             akka-misc : "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote"
                             primitive : "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote"
                             proto : "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote"
                             daemon-create : "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote"
                             akka-system-msg : "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote"
                             akka-cluster : "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster"
                             akka-pubsub : "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools"
                             hyperion : "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion"
                           }
                           serialization-bindings : {
                             System.Byte[] : bytes
                             System.Object : hyperion
                             "Akka.Actor.ActorSelectionMessage, Akka" : akka-containers
                             "Akka.Remote.DaemonMsgCreate, Akka.Remote" : daemon-create
                             "Google.Protobuf.IMessage, Google.Protobuf" : proto
                             "Akka.Actor.Identify, Akka" : akka-misc
                             "Akka.Actor.ActorIdentity, Akka" : akka-misc
                             "Akka.Actor.IActorRef, Akka" : akka-misc
                             "Akka.Actor.PoisonPill, Akka" : akka-misc
                             "Akka.Actor.Kill, Akka" : akka-misc
                             "Akka.Actor.Status+Failure, Akka" : akka-misc
                             "Akka.Actor.Status+Success, Akka" : akka-misc
                             "Akka.Actor.RemoteScope, Akka" : akka-misc
                             "Akka.Routing.FromConfig, Akka" : akka-misc
                             "Akka.Routing.DefaultResizer, Akka" : akka-misc
                             "Akka.Routing.RoundRobinPool, Akka" : akka-misc
                             "Akka.Routing.BroadcastPool, Akka" : akka-misc
                             "Akka.Routing.RandomPool, Akka" : akka-misc
                             "Akka.Routing.ScatterGatherFirstCompletedPool, Akka" : akka-misc
                             "Akka.Routing.TailChoppingPool, Akka" : akka-misc
                             "Akka.Routing.ConsistentHashingPool, Akka" : akka-misc
                             "Akka.Configuration.Config, Akka" : akka-misc
                             "Akka.Remote.RemoteWatcher+Heartbeat, Akka.Remote" : akka-misc
                             "Akka.Remote.RemoteWatcher+HeartbeatRsp, Akka.Remote" : akka-misc
                             "Akka.Remote.Routing.RemoteRouterConfig, Akka.Remote" : akka-misc
                             "Akka.Dispatch.SysMsg.SystemMessage, Akka" : akka-system-msg
                             System.String : primitive
                             System.Int32 : primitive
                             System.Int64 : primitive
                             "Akka.Cluster.IClusterMessage, Akka.Cluster" : akka-cluster
                             "Akka.Cluster.Routing.ClusterRouterPool, Akka.Cluster" : akka-cluster
                             "Akka.Cluster.Tools.PublishSubscribe.IDistributedPubSubMessage, Akka.Cluster.Tools" : akka-pubsub
                             "Akka.Cluster.Tools.PublishSubscribe.Internal.SendToOneSubscriber, Akka.Cluster.Tools" : akka-pubsub
                           }
                           serialization-identifiers : {
                             "Akka.Serialization.ByteArraySerializer, Akka" : 4
                             "Akka.Serialization.NewtonSoftJsonSerializer, Akka" : 1
                             "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" : 2
                             "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" : 3
                             "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" : 6
                             "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" : 16
                             "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" : 17
                             "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" : 22
                             "Akka.Cluster.Serialization.ClusterMessageSerializer, Akka.Cluster" : 5
                             "Akka.Cluster.Tools.PublishSubscribe.Serialization.DistributedPubSubMessageSerializer, Akka.Cluster.Tools" : 9
                             "Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion" : -5
                           }
                           serialization-settings : {
                             json : {
                               use-pooled-string-builder : true
                               pooled-string-builder-minsize : 2048
                               pooled-string-builder-maxsize : 32768
                             }
                             primitive : {
                               use-legacy-behavior : on
                             }
                           }
                         }
                         channel-scheduler : {
                           parallelism-min : 4
                           parallelism-factor : 1
                           parallelism-max : 64
                           work-max : 10
                           work-interval : 500
                           work-step : 2
                         }
                         scheduler : {
                           tick-duration : 10ms
                           ticks-per-wheel : 512
                           implementation : Akka.Actor.HashedWheelTimerScheduler
                           shutdown-timeout : 5s
                         }
                         io : {
                           pinned-dispatcher : {
                             type : PinnedDispatcher
                             executor : fork-join-executor
                           }
                           tcp : {
                             direct-buffer-pool : {
                               class : "Akka.IO.Buffers.DirectBufferPool, Akka"
                               buffer-size : 512
                               buffers-per-segment : 500
                               initial-segments : 1
                               buffer-pool-limit : 1024
                             }
                             disabled-buffer-pool : {
                               class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
                               buffer-size : 512
                             }
                             buffer-pool : akka.io.tcp.disabled-buffer-pool
                             max-channels : 256000
                             selector-association-retries : 10
                             batch-accept-limit : 10
                             register-timeout : 5s
                             max-received-message-size : unlimited
                             trace-logging : off
                             selector-dispatcher : akka.io.pinned-dispatcher
                             worker-dispatcher : akka.actor.internal-dispatcher
                             management-dispatcher : akka.actor.internal-dispatcher
                             file-io-dispatcher : akka.actor.default-blocking-io-dispatcher
                             file-io-transferTo-limit : 524288
                             finish-connect-retries : 5
                             windows-connection-abort-workaround-enabled : off
                             outgoing-socket-force-ipv4 : false
                           }
                           udp : {
                             direct-buffer-pool : {
                               class : "Akka.IO.Buffers.DirectBufferPool, Akka"
                               buffer-size : 512
                               buffers-per-segment : 500
                               initial-segments : 1
                               buffer-pool-limit : 1024
                             }
                             disabled-buffer-pool : {
                               class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
                               buffer-size : 512
                             }
                             buffer-pool : akka.io.udp.disabled-buffer-pool
                             nr-of-socket-async-event-args : 32
                             max-channels : 4096
                             select-timeout : infinite
                             selector-association-retries : 10
                             receive-throughput : 3
                             received-message-size-limit : unlimited
                             trace-logging : off
                             selector-dispatcher : akka.io.pinned-dispatcher
                             worker-dispatcher : akka.actor.internal-dispatcher
                             management-dispatcher : akka.actor.internal-dispatcher
                           }
                           udp-connected : {
                             direct-buffer-pool : {
                               class : "Akka.IO.Buffers.DirectBufferPool, Akka"
                               buffer-size : 512
                               buffers-per-segment : 500
                               initial-segments : 1
                               buffer-pool-limit : 1024
                             }
                             disabled-buffer-pool : {
                               class : "Akka.IO.Buffers.DisabledBufferPool, Akka"
                               buffer-size : 512
                             }
                             buffer-pool : akka.io.udp-connected.disabled-buffer-pool
                             nr-of-socket-async-event-args : 32
                             max-channels : 4096
                             select-timeout : infinite
                             selector-association-retries : 10
                             receive-throughput : 3
                             received-message-size-limit : unlimited
                             trace-logging : off
                             selector-dispatcher : akka.io.pinned-dispatcher
                             worker-dispatcher : akka.actor.internal-dispatcher
                             management-dispatcher : akka.actor.internal-dispatcher
                           }
                           dns : {
                             dispatcher : akka.actor.internal-dispatcher
                             resolver : inet-address
                             inet-address : {
                               provider-object : Akka.IO.InetAddressDnsProvider
                               positive-ttl : 30s
                               negative-ttl : 10s
                               cache-cleanup-interval : 120s
                               use-ipv6 : true
                             }
                           }
                         }
                         coordinated-shutdown : {
                           default-phase-timeout : "5 s"
                           terminate-actor-system : on
                           exit-clr : off
                           run-by-clr-shutdown-hook : on
                           run-by-actor-system-terminate : on
                           phases : {
                             before-service-unbind : {
                             }
                             service-unbind : {
                               depends-on : [before-service-unbind]
                             }
                             service-requests-done : {
                               depends-on : [service-unbind]
                             }
                             service-stop : {
                               depends-on : [service-requests-done]
                             }
                             before-cluster-shutdown : {
                               depends-on : [service-stop]
                             }
                             cluster-sharding-shutdown-region : {
                               timeout : "10 s"
                               depends-on : [before-cluster-shutdown]
                             }
                             cluster-leave : {
                               depends-on : [cluster-sharding-shutdown-region]
                             }
                             cluster-exiting : {
                               timeout : "10 s"
                               depends-on : [cluster-leave]
                             }
                             cluster-exiting-done : {
                               depends-on : [cluster-exiting]
                             }
                             cluster-shutdown : {
                               depends-on : [cluster-exiting-done]
                             }
                             before-actor-system-terminate : {
                               depends-on : [cluster-shutdown]
                             }
                             actor-system-terminate : {
                               timeout : "10 s"
                               depends-on : [before-actor-system-terminate]
                             }
                           }
                         }
                         remote : {
                           startup-timeout : "10 s"
                           shutdown-timeout : "10 s"
                           flush-wait-on-shutdown : "2 s"
                           use-passive-connections : on
                           backoff-interval : "0.05 s"
                           command-ack-timeout : "30 s"
                           handshake-timeout : "15 s"
                           use-dispatcher : akka.remote.default-remote-dispatcher
                           untrusted-mode : off
                           trusted-selection-paths : <<unknown value>>
                           require-cookie : off
                           secure-cookie : 
                           log-received-messages : off
                           log-sent-messages : off
                           log-remote-lifecycle-events : on
                           log-frame-size-exceeding : off
                           log-buffer-size-exceeding : 50000
                           transport-failure-detector : {
                             implementation-class : Akka.Remote.DeadlineFailureDetector,Akka.Remote
                             heartbeat-interval : "4 s"
                             acceptable-heartbeat-pause : "120 s"
                           }
                           watch-failure-detector : {
                             implementation-class : Akka.Remote.PhiAccrualFailureDetector,Akka.Remote
                             heartbeat-interval : "1 s"
                             threshold : 10.0
                             max-sample-size : 200
                             min-std-deviation : "100 ms"
                             acceptable-heartbeat-pause : "10 s"
                             unreachable-nodes-reaper-interval : 1s
                             expected-response-after : "1 s"
                           }
                           retry-gate-closed-for : "5 s"
                           prune-quarantine-marker-after : "5 d"
                           quarantine-after-silence : "2 d"
                           system-message-buffer-size : 20000
                           system-message-ack-piggyback-timeout : "0.3 s"
                           resend-interval : "2 s"
                           resend-limit : 200
                           initial-system-message-delivery-timeout : "3 m"
                           enabled-transports : [akka.remote.dot-netty.tcp]
                           adapters : {
                             gremlin : Akka.Remote.Transport.FailureInjectorProvider,Akka.Remote
                             trttl : Akka.Remote.Transport.ThrottlerProvider,Akka.Remote
                           }
                           helios : {
                             tcp : {
                               transport-class : "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote.Transport.Helios"
                             }
                           }
                           dot-netty : {
                             tcp : {
                               transport-class : Akka.Remote.Transport.DotNetty.TcpTransport,Akka.Remote
                               applied-adapters : <<unknown value>>
                               transport-protocol : tcp
                               byte-order : little-endian
                               port : 9011
                               public-port : 0
                               hostname : 
                               public-hostname : 10.6.36.66
                               dns-use-ipv6 : false
                               enforce-ip-family : false
                               enable-ssl : false
                               enable-backwards-compatibility : false
                               connection-timeout : "15 s"
                               batching : {
                                 enabled : true
                                 max-pending-writes : 30
                               }
                               use-dispatcher-for-io : 
                               write-buffer-high-water-mark : 0b
                               write-buffer-low-water-mark : 0b
                               send-buffer-size : 6MiB
                               receive-buffer-size : 6MiB
                               maximum-frame-size : 6MiB
                               backlog : 4096
                               tcp-nodelay : on
                               tcp-keepalive : on
                               tcp-reuse-addr : off-for-windows
                               server-socket-worker-pool : {
                                 pool-size-min : 2
                                 pool-size-factor : 1.0
                                 pool-size-max : 2
                               }
                               client-socket-worker-pool : {
                                 pool-size-min : 2
                                 pool-size-factor : 1.0
                                 pool-size-max : 2
                               }
                               message-frame-size : 6MiB
                             }
                             udp : {
                               transport-protocol : udp
                             }
                             ssl : {
                               certificate : {
                                 path : 
                                 password : 
                                 use-thumbprint-over-file : false
                                 thumbprint : 
                                 store-name : 
                                 store-location : current-user
                               }
                               suppress-validation : false
                             }
                           }
                           gremlin : {
                             debug : off
                           }
                           default-remote-dispatcher : {
                             executor : fork-join-executor
                             fork-join-executor : {
                               parallelism-min : 2
                               parallelism-factor : 0.5
                               parallelism-max : 16
                             }
                             channel-executor : {
                               priority : high
                             }
                           }
                           backoff-remote-dispatcher : {
                             executor : fork-join-executor
                             fork-join-executor : {
                               parallelism-min : 2
                               parallelism-max : 2
                             }
                             channel-executor : {
                               priority : low
                             }
                           }
                         }
                         cluster : {
                           seed-nodes : ["akka.tcp://ClusterSystem@**.**.**.**:****","akka.tcp://ClusterSystem@**.**.**.**:****"]
                           seed-node-timeout : 5s
                           retry-unsuccessful-join-after : 10s
                           shutdown-after-unsuccessful-join-seed-nodes : 60s
                           auto-down-unreachable-after : off
                           down-removal-margin : 20s
                           downing-provider-class : "Akka.Cluster.SplitBrainResolver, Akka.Cluster"
                           allow-weakly-up-members : on
                           roles : [receptionist]
                           app-version : assembly-version
                           run-coordinated-shutdown-when-down : on
                           role : {
                           }
                           min-nr-of-members : 1
                           log-info : on
                           log-info-verbose : off
                           periodic-tasks-initial-delay : 1s
                           gossip-interval : 1s
                           gossip-time-to-live : 2s
                           leader-actions-interval : 1s
                           unreachable-nodes-reaper-interval : 1s
                           publish-stats-interval : off
                           use-dispatcher : 
                           gossip-different-view-probability : 0.8
                           reduce-gossip-different-view-probability : 400
                           failure-detector : {
                             implementation-class : "Akka.Remote.PhiAccrualFailureDetector, Akka.Remote"
                             heartbeat-interval : "1 s"
                             threshold : 8.0
                             max-sample-size : 1000
                             min-std-deviation : "100 ms"
                             acceptable-heartbeat-pause : "3 s"
                             monitored-by-nr-of-members : 9
                             expected-response-after : "1 s"
                           }
                           scheduler : {
                             tick-duration : 33ms
                             ticks-per-wheel : 512
                           }
                           debug : {
                             verbose-heartbeat-logging : off
                             verbose-receive-gossip-logging : off
                           }
                           split-brain-resolver : {
                             active-strategy : keep-majority
                             stable-after : 20s
                             down-all-when-unstable : on
                             static-quorum : {
                               quorum-size : undefined
                               role : 
                             }
                             keep-majority : {
                               role : receptionist
                             }
                             keep-oldest : {
                               down-if-alone : on
                               role : 
                             }
                             lease-majority : {
                               lease-implementation : 
                               lease-name : 
                               acquire-lease-delay-for-minority : 2s
                               release-after : 40s
                               role : 
                             }
                             keep-referee : {
                               address : 
                               down-all-if-less-than-nodes : 1
                             }
                           }
                           pub-sub : {
                             name : distributedPubSubMediator
                             role : 
                             routing-logic : random
                             gossip-interval : 1s
                             removed-time-to-live : 120s
                             max-delta-elements : 3000
                             send-to-dead-letters-when-no-subscribers : on
                             use-dispatcher : 
                           }
                         }
                       }
                     

@ayooyeyipo
Copy link
Author

ayooyeyipo commented Jun 26, 2023

Not sure why Status.Failure is being handled by Hyperion. In Akka.NET v1.4.47 we added a dedicated Protobuf layer to handle it: #6297

That's one issue, but the yours is simpler:

Cause: Index was outside the bounds of the array. Could not find any internal Akka.NET serializer with Id [-5]. 

This is a configuration problem - Hyperion is missing from your system's configuration. Can you please provide your configuration and any Setup classes you're using to configure your ActorSystem?

Can I upgrade to Akka 1.4.46 and the akka version of the other services in the cluster are below 1.4.46

@Arkatufus
Copy link
Contributor

@ayooyeyipo I think that is the best course of action for now, 1.4.46 would be the most updated version that has the closest serialization model with 1.3.14

@Aaronontheweb
Copy link
Member

Closing this issue for now.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

3 participants