problem: NativeCall replies are logged only on complete

solution: add to the log at the moment of reply

src/main/kotlin/io/emeraldpay/dshackle/monitoring/accesslog/AccessHandler.kt

@@ -110,13 +110,14 @@ class AccessHandler(
                 .start(headers, call.attributes)
 
         val callWrapper: ServerCall<ReqT, RespT> = OnNativeCallResponse(
-                call as ServerCall<BlockchainOuterClass.NativeCallRequest, BlockchainOuterClass.NativeCallReplyItem>, builder
+                call as ServerCall<BlockchainOuterClass.NativeCallRequest, BlockchainOuterClass.NativeCallReplyItem>,
+                builder,
+                accessLogWriter
         ) as ServerCall<ReqT, RespT>
         return OnNativeCall(
                 next.startCall(callWrapper, headers) as ServerCall.Listener<BlockchainOuterClass.NativeCallRequest>,
-                builder) { logs ->
-            accessLogWriter.submit(logs)
-        } as ServerCall.Listener<ReqT>
+                builder
+        ) as ServerCall.Listener<ReqT>
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -205,29 +206,18 @@ class AccessHandler(
 
     class OnNativeCall(
             val next: ServerCall.Listener<BlockchainOuterClass.NativeCallRequest>,
-            val builder: EventsBuilder.NativeCall,
-            val done: (List<Events.NativeCall>) -> Unit
+            val builder: EventsBuilder.NativeCall
     ) : ForwardingServerCallListener<BlockchainOuterClass.NativeCallRequest>() {
 
         override fun onMessage(message: BlockchainOuterClass.NativeCallRequest) {
             val chain = message.chain
             builder.withChain(chain.number)
             message.itemsList.forEach { item ->
-                builder.onItem(item)
+                builder.onRequest(item)
             }
             super.onMessage(message)
         }
 
-        override fun onCancel() {
-            super.onCancel()
-            done(builder.build())
-        }
-
-        override fun onComplete() {
-            super.onComplete()
-            done(builder.build())
-        }
-
         override fun delegate(): ServerCall.Listener<BlockchainOuterClass.NativeCallRequest> {
             return next
         }
@@ -279,11 +269,14 @@ class AccessHandler(
 
     class OnNativeCallResponse(
             next: ServerCall<BlockchainOuterClass.NativeCallRequest, BlockchainOuterClass.NativeCallReplyItem>,
-            val builder: EventsBuilder.NativeCall
+            val builder: EventsBuilder.NativeCall,
+            val accessLogWriter: AccessLogWriter
     ) : BaseCallResponse<BlockchainOuterClass.NativeCallRequest, BlockchainOuterClass.NativeCallReplyItem>(next) {
 
         override fun sendMessage(message: BlockchainOuterClass.NativeCallReplyItem) {
-            builder.onItemReply(message)
+            accessLogWriter.submit(
+                    builder.onReply(message)
+            )
             super.sendMessage(message)
         }
     }

src/main/kotlin/io/emeraldpay/dshackle/monitoring/accesslog/EventsBuilder.kt

@@ -186,12 +186,13 @@ class EventsBuilder {
     class NativeCall : Base<NativeCall>() {
         val items = ArrayList<Events.NativeCallItemDetails>()
         val replies = HashMap<Int, Events.NativeCallReplyDetails>()
+        private var index = 0
 
         override fun getT(): NativeCall {
             return this
         }
 
-        fun onItem(item: BlockchainOuterClass.NativeCallItem): NativeCall {
+        fun onRequest(item: BlockchainOuterClass.NativeCallItem): NativeCall {
             this.items.add(
                     Events.NativeCallItemDetails(
                             item.method,
@@ -202,30 +203,20 @@ class EventsBuilder {
             return this
         }
 
-        fun onItemReply(reply: BlockchainOuterClass.NativeCallReplyItem): NativeCall {
-            this.replies[reply.id] = Events.NativeCallReplyDetails(
-                    reply.id,
-                    reply.succeed,
-                    reply.payload?.size()?.toLong() ?: 0L
+        fun onReply(reply: BlockchainOuterClass.NativeCallReplyItem): Events.NativeCall {
+            val item = items.find { it.id == reply.id }!!
+            return Events.NativeCall(
+                    request = requestDetails,
+                    total = items.size,
+                    index = index++,
+                    succeed = reply.succeed,
+                    blockchain = chain,
+                    nativeCall = item,
+                    payloadSizeBytes = item.payloadSizeBytes,
+                    id = UUID.randomUUID()
             )
-            return this
         }
 
-        fun build(): List<Events.NativeCall> {
-            return items.mapIndexed { index, item ->
-                val reply = replies[item.id]
-                Events.NativeCall(
-                        request = requestDetails,
-                        total = items.size,
-                        index = index,
-                        succeed = reply?.succeed ?: false,
-                        blockchain = chain,
-                        nativeCall = item,
-                        payloadSizeBytes = item.payloadSizeBytes,
-                        id = UUID.randomUUID()
-                )
-            }
-        }
     }
 
     class Describe : Base<Describe>() {