Merge remote-tracking branch 'gh-hiddenalpha/master'

12 files changed, 1163 insertions, 7 deletions

diff --git a/doc/note/curl/curl.txt b/doc/note/curl/curl.txt
index b5a3556..fe0302b 100644
--- a/doc/note/curl/curl.txt
+++ b/doc/note/curl/curl.txt
@@ -2,9 +2,7 @@
 
 ## Timing
 
-  curl example.com -w "\n\nconnect=%{time_connect}s, trsf=%{time_starttransfer}s, totl=%{time_total}s"
-
-
+  curl example.com -w "\n\nconnect=%{time_connect}s, trsf=%{time_starttransfer}s, totl=%{time_total}s\n"
 
 
 ## Sources
diff --git a/doc/note/links/links.txt b/doc/note/links/links.txt
index 8f7462c..d187788 100644
--- a/doc/note/links/links.txt
+++ b/doc/note/links/links.txt
@@ -239,7 +239,7 @@ Links (Aka argument amplifiers)
 ## Performance DOES matter
 - "https://github.com/swisspush/gateleen/pull/456#discussion_r844865066"
 - [Performance Excuses Debunked](https://m.youtube.com/watch?v=x2EOOJg8FkA)
-- [Frameworks & clusters do not solve it](https://www.youtube.com/watch?v=EpYr3T5VP6w&t=1109)
+- [Is writing performant code too expensive?](https://www.youtube.com/watch?v=EpYr3T5VP6w&t=1109)
 - [Simple Code, High Performance](https://m.youtube.com/watch?v=Ge3aKEmZcqY&t=78)
 - [Houston Last führt zu Neustart](https://wikit.post.ch/x/HDV8T)
 - [Houston storage request timed out large json](https://jira.post.ch/browse/SDCISA-11294)
@@ -252,6 +252,7 @@ Links (Aka argument amplifiers)
 - [2023-10-27 OOM nun auch auf Eagle](https://wikit.post.ch/x/c2U1Tw)
 - [Fahrplanimports slow](https://jira.post.ch/browse/SDCISA-11528)
 - [Jenkinsbuild too slow](https://jira.post.ch/browse/SDCISA-14313?focusedId=1914236&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-1914236)
+- [Houston check too slow](https://jira.post.ch/browse/SDCISA-13746?focusedId=1937167&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-1937167)
 
 ## Performance is not an issue ...
 - [Houston OOM 2023-06-27](https://wikit.post.ch/x/_Bv6Rw)
@@ -572,3 +573,6 @@ Links (Aka argument amplifiers)
 
 [About TLS in isa](https://jira.post.ch/browse/SDCISA-14330?focusedId=1925001&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-1925001)
 
+## Tools like tcpdump are incredibly important
+- [tcpdump discovers the truth once more](https://jira.post.ch/browse/SDCISA-13746?focusedId=1939377&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-1939377)
+
diff --git a/doc/note/openshift/openshift.txt b/doc/note/openshift/openshift.txt
index e807da3..48fda8f 100644
--- a/doc/note/openshift/openshift.txt
+++ b/doc/note/openshift/openshift.txt
@@ -79,8 +79,16 @@ HINT: ALL files from Current dir (.) will get uploaded (when global rsync not av
 
   oc scale dc/preflux --replicas=1
 
-## TODO what was this for?
 
-  oc get pvc
+
+## Kube Probe
+
+  echo && ocprod exec -ti "$(ocprod get pods|egrep ston-[0-9]|cut -f1 -d' ')" -- sh -c 'true \
+    && printf "c; When                    ; rsp_code; time_connect; time_redirect; time_starttransfer; time_total\n" \
+    && while true; do true \
+       && now=$(date -uIs) \
+       && curl -sS -o/dev/null -w "r; $(date -uIs);      %{response_code};       %{time_connect}s;        %{time_redirect}s;             %{time_starttransfer}s;     %{time_total}s\n" 127.0.0.1:7012/houston/server/info \
+       && sleep 5 || break \
+    ;done' | tee -a C:/work/tmp/houston-prod-inPod-probe.log
 
 
diff --git a/doc/note/tcpdump/tcpdump.txt b/doc/note/tcpdump/tcpdump.txt
index 7df4335..71ffb02 100644
--- a/doc/note/tcpdump/tcpdump.txt
+++ b/doc/note/tcpdump/tcpdump.txt
@@ -62,6 +62,15 @@ Tips: "https://chrissanders.org/2018/06/large-captures4-filter-whittling/"
   "net 172.18.0.0/16"
 
 
+## Filter kube-probes "GET /houston/server/info" or '{"name":"houston",'
+
+  tcpdump -nni any -w /tmp/houston-${PAISA_ENV:?}-tcp-$(date -u +%Y%m%d-%H%M%SZ)-%s.pcap -C 8M -W 99 -G 600 "(tcp[((tcp[12:1]&0xf0)>>2)+0:4] = 0x47455420 && tcp[((tcp[12:1]&0xf0)>>2)+4:4] = 0x2F686F75 && tcp[((tcp[12:1]&0xf0)>>2)+8:4] = 0x73746F6E && tcp[((tcp[12:1]&0xf0)>>2)+12:4] = 0x2F736572 && tcp[((tcp[12:1]&0xf0)>>2)+16:4] = 0x7665722F && tcp[((tcp[12:1]&0xf0)>>2)+20:4] = 0x696E666F && tcp[((tcp[12:1]&0xf0)>>2)+24:1] = 0x20) or (tcp[((tcp[12:1]&0xf0)>>2)+115:4] = 0x7B226E61 && tcp[((tcp[12:1]&0xf0)>>2)+119:4] = 0x6D65223A && tcp[((tcp[12:1]&0xf0)>>2)+123:4] = 0x22686F75 && tcp[((tcp[12:1]&0xf0)>>2)+127:4] = 0x73746F6E && tcp[((tcp[12:1]&0xf0)>>2)+131:2] = 0x222C)"
+
+
+## Try dump kube-probes fully
+
+  timeout --foreground 900 tcpdump -nni any -w /tmp/houston-${PAISA_ENV:?}-tcp-$(date -u +%Y%m%d-%H%M%SZ)-%s.pcap -C 42M -W 42 -G 600 "host 10.127.73.1 and port 7012"
+
 
 ## Extract hosts file from DNS traffic
 
@@ -71,3 +80,8 @@ Not perfect because needs manual fine-tuning. But can be helpful anyway.
 
 Vielleicht auch mal option "-zhosts" ausprobieren. Sollte auch sowas tun.
 
+
+[man tcpdump](https://www.tcpdump.org/manpages/tcpdump.1.html)
+[no name port numbers rhel patch](https://superuser.com/a/587304/1123359)
+[complex filter by byte contents](https://security.stackexchange.com/a/121013/179017)
+
diff --git a/doc/note/msteams/msteams.txt b/doc/note/windoof/msteams.txt
index 216c9ce..216c9ce 100644
--- a/doc/note/msteams/msteams.txt
+++ b/doc/note/windoof/msteams.txt
diff --git a/doc/note/windoof/msys-path-issue.txt b/doc/note/windoof/msys-path-issue.txt
new file mode 100644
index 0000000..0b49323
--- /dev/null
+++ b/doc/note/windoof/msys-path-issue.txt
@@ -0,0 +1,3 @@
+
+MSYS_NO_PATHCONV=1
+
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java
new file mode 100644
index 0000000..aa4ad48
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java
@@ -0,0 +1,394 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.netty.handler.codec.DecoderResult;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpConnection;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerFileUpload;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.HttpVersion;
+import io.vertx.core.http.ServerWebSocket;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
+import io.vertx.core.streams.Pipe;
+import io.vertx.core.streams.WriteStream;
+
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.cert.X509Certificate;
+import java.util.Map;
+import java.util.Set;
+
+public class DelegateHttpServerRequest implements io.vertx.core.http.HttpServerRequest {
+
+    private final io.vertx.core.http.HttpServerRequest delegate;
+    private final boolean isDebugging = true;
+
+    public DelegateHttpServerRequest(HttpServerRequest delegate) {
+        this.delegate = delegate;
+    }
+
+    private void breakpoint(){
+        try{
+            throw new UnsupportedOperationException();
+        }catch(UnsupportedOperationException ex){}
+    }
+
+    @Override
+    public HttpServerRequest exceptionHandler(Handler<Throwable> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.exceptionHandler(handler);
+    }
+
+    @Override
+    public HttpServerRequest handler(Handler<Buffer> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.handler(handler);
+    }
+
+    @Override
+    public HttpServerRequest pause() {
+        if( isDebugging ) breakpoint();
+        return delegate.pause();
+    }
+
+    @Override
+    public HttpServerRequest resume() {
+        if( isDebugging ) breakpoint();
+        return delegate.resume();
+    }
+
+    @Override
+    public HttpServerRequest fetch(long amount) {
+        if( isDebugging ) breakpoint();
+        return delegate.fetch(amount);
+    }
+
+    @Override
+    public HttpServerRequest endHandler(Handler<Void> endHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.endHandler(endHandler);
+    }
+
+    @Override
+    public HttpVersion version() {
+        if( isDebugging ) breakpoint();
+        return delegate.version();
+    }
+
+    @Override
+    public HttpMethod method() {
+        if( isDebugging ) breakpoint();
+        return delegate.method();
+    }
+
+    @Override
+    public boolean isSSL() {
+        if( isDebugging ) breakpoint();
+        return delegate.isSSL();
+    }
+
+    @Override
+    public String scheme() {
+        if( isDebugging ) breakpoint();
+        return delegate.scheme();
+    }
+
+    @Override
+    public String uri() {
+        if( isDebugging ) breakpoint();
+        return delegate.uri();
+    }
+
+    @Override
+    public String path() {
+        if( isDebugging ) breakpoint();
+        return delegate.path();
+    }
+
+    @Override
+    public String query() {
+        if( isDebugging ) breakpoint();
+        return delegate.query();
+    }
+
+    @Override
+    public String host() {
+        if( isDebugging ) breakpoint();
+        return delegate.host();
+    }
+
+    @Override
+    public long bytesRead() {
+        if( isDebugging ) breakpoint();
+        return delegate.bytesRead();
+    }
+
+    @Override
+    public HttpServerResponse response() {
+        if( isDebugging ) breakpoint();
+        return delegate.response();
+    }
+
+    @Override
+    public MultiMap headers() {
+        if( isDebugging ) breakpoint();
+        return delegate.headers();
+    }
+
+    @Override
+    public String getHeader(String headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public String getHeader(CharSequence headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public MultiMap params() {
+        if( isDebugging ) breakpoint();
+        return delegate.params();
+    }
+
+    @Override
+    public String getParam(String paramName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName);
+    }
+
+    @Override
+    public String getParam(String paramName, String defaultValue) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName, defaultValue);
+    }
+
+    @Override
+    public SocketAddress remoteAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.remoteAddress();
+    }
+
+    @Override
+    public SocketAddress localAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.localAddress();
+    }
+
+    @Override
+    public SSLSession sslSession() {
+        if( isDebugging ) breakpoint();
+        return delegate.sslSession();
+    }
+
+    @Override
+    public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException {
+        if( isDebugging ) breakpoint();
+        return delegate.peerCertificateChain();
+    }
+
+    @Override
+    public String absoluteURI() {
+        if( isDebugging ) breakpoint();
+        return delegate.absoluteURI();
+    }
+
+    @Override
+    public HttpServerRequest bodyHandler(Handler<Buffer> bodyHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.bodyHandler(bodyHandler);
+    }
+
+    @Override
+    public HttpServerRequest body(Handler<AsyncResult<Buffer>> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.body(handler);
+    }
+
+    @Override
+    public Future<Buffer> body() {
+        if( isDebugging ) breakpoint();
+        return delegate.body();
+    }
+
+    @Override
+    public void end(Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.end(handler);
+    }
+
+    @Override
+    public Future<Void> end() {
+        if( isDebugging ) breakpoint();
+        return delegate.end();
+    }
+
+    @Override
+    public void toNetSocket(Handler<AsyncResult<NetSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toNetSocket(handler);
+    }
+
+    @Override
+    public Future<NetSocket> toNetSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toNetSocket();
+    }
+
+    @Override
+    public HttpServerRequest setExpectMultipart(boolean expect) {
+        if( isDebugging ) breakpoint();
+        return delegate.setExpectMultipart(expect);
+    }
+
+    @Override
+    public boolean isExpectMultipart() {
+        if( isDebugging ) breakpoint();
+        return delegate.isExpectMultipart();
+    }
+
+    @Override
+    public HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.uploadHandler(uploadHandler);
+    }
+
+    @Override
+    public MultiMap formAttributes() {
+        if( isDebugging ) breakpoint();
+        return delegate.formAttributes();
+    }
+
+    @Override
+    public String getFormAttribute(String attributeName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getFormAttribute(attributeName);
+    }
+
+    @Override
+    public int streamId() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamId();
+    }
+
+    @Override
+    public void toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toWebSocket(handler);
+    }
+
+    @Override
+    public Future<ServerWebSocket> toWebSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toWebSocket();
+    }
+
+    @Override
+    public boolean isEnded() {
+        if( isDebugging ) breakpoint();
+        return delegate.isEnded();
+    }
+
+    @Override
+    public HttpServerRequest customFrameHandler(Handler<HttpFrame> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.customFrameHandler(handler);
+    }
+
+    @Override
+    public HttpConnection connection() {
+        if( isDebugging ) breakpoint();
+        return delegate.connection();
+    }
+
+    @Override
+    public StreamPriority streamPriority() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriority();
+    }
+
+    @Override
+    public HttpServerRequest streamPriorityHandler(Handler<StreamPriority> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriorityHandler(handler);
+    }
+
+    @Override
+    public DecoderResult decoderResult() {
+        if( isDebugging ) breakpoint();
+        return delegate.decoderResult();
+    }
+
+    @Override
+    public Cookie getCookie(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name);
+    }
+
+    @Override
+    public Cookie getCookie(String name, String domain, String path) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name, domain, path);
+    }
+
+    @Override
+    public int cookieCount() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieCount();
+    }
+
+    @Override
+    @Deprecated
+    public Map<String, Cookie> cookieMap() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieMap();
+    }
+
+    @Override
+    public Set<Cookie> cookies(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies(name);
+    }
+
+    @Override
+    public Set<Cookie> cookies() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies();
+    }
+
+    @Override
+    public HttpServerRequest routed(String route) {
+        if( isDebugging ) breakpoint();
+        return delegate.routed(route);
+    }
+
+    @Override
+    public Pipe<Buffer> pipe() {
+        if( isDebugging ) breakpoint();
+        return delegate.pipe();
+    }
+
+    @Override
+    public Future<Void> pipeTo(WriteStream<Buffer> dst) {
+        if( isDebugging ) breakpoint();
+        return delegate.pipeTo(dst);
+    }
+
+    @Override
+    public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.pipeTo(dst, handler);
+    }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java
new file mode 100644
index 0000000..16c7259
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java
@@ -0,0 +1,408 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.netty.handler.codec.DecoderResult;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Context;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpConnection;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerFileUpload;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.HttpVersion;
+import io.vertx.core.http.ServerWebSocket;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.http.impl.HttpServerRequestInternal;
+import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
+import io.vertx.core.streams.Pipe;
+import io.vertx.core.streams.WriteStream;
+
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.cert.X509Certificate;
+import java.util.Map;
+import java.util.Set;
+
+public class DelegateVertxHttpServerRequestInternal implements HttpServerRequestInternal {
+
+    private final HttpServerRequestInternal delegate;
+    private final boolean isDebugging = true;
+
+    public DelegateVertxHttpServerRequestInternal(HttpServerRequest delegate) {
+        this.delegate = (HttpServerRequestInternal) delegate;
+    }
+
+    private void breakpoint(){
+        try{
+            throw new UnsupportedOperationException();
+        }catch(UnsupportedOperationException ex){}
+    }
+
+    @Override
+    public HttpServerRequest exceptionHandler(Handler<Throwable> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.exceptionHandler(handler);
+    }
+
+    @Override
+    public HttpServerRequest handler(Handler<Buffer> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.handler(handler);
+    }
+
+    @Override
+    public HttpServerRequest pause() {
+        if( isDebugging ) breakpoint();
+        return delegate.pause();
+    }
+
+    @Override
+    public HttpServerRequest resume() {
+        if( isDebugging ) breakpoint();
+        return delegate.resume();
+    }
+
+    @Override
+    public HttpServerRequest fetch(long amount) {
+        if( isDebugging ) breakpoint();
+        return delegate.fetch(amount);
+    }
+
+    @Override
+    public HttpServerRequest endHandler(Handler<Void> endHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.endHandler(endHandler);
+    }
+
+    @Override
+    public HttpVersion version() {
+        if( isDebugging ) breakpoint();
+        return delegate.version();
+    }
+
+    @Override
+    public HttpMethod method() {
+        if( isDebugging ) breakpoint();
+        return delegate.method();
+    }
+
+    @Override
+    public boolean isSSL() {
+        if( isDebugging ) breakpoint();
+        return delegate.isSSL();
+    }
+
+    @Override
+    public String scheme() {
+        if( isDebugging ) breakpoint();
+        return delegate.scheme();
+    }
+
+    @Override
+    public String uri() {
+        if( isDebugging ) breakpoint();
+        return delegate.uri();
+    }
+
+    @Override
+    public String path() {
+        if( isDebugging ) breakpoint();
+        return delegate.path();
+    }
+
+    @Override
+    public String query() {
+        if( isDebugging ) breakpoint();
+        return delegate.query();
+    }
+
+    @Override
+    public String host() {
+        if( isDebugging ) breakpoint();
+        return delegate.host();
+    }
+
+    @Override
+    public long bytesRead() {
+        if( isDebugging ) breakpoint();
+        return delegate.bytesRead();
+    }
+
+    @Override
+    public HttpServerResponse response() {
+        if( isDebugging ) breakpoint();
+        return delegate.response();
+    }
+
+    @Override
+    public MultiMap headers() {
+        if( isDebugging ) breakpoint();
+        return delegate.headers();
+    }
+
+    @Override
+    public String getHeader(String headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public String getHeader(CharSequence headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public MultiMap params() {
+        if( isDebugging ) breakpoint();
+        return delegate.params();
+    }
+
+    @Override
+    public String getParam(String paramName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName);
+    }
+
+    @Override
+    public String getParam(String paramName, String defaultValue) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName, defaultValue);
+    }
+
+    @Override
+    public SocketAddress remoteAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.remoteAddress();
+    }
+
+    @Override
+    public SocketAddress localAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.localAddress();
+    }
+
+    @Override
+    public SSLSession sslSession() {
+        if( isDebugging ) breakpoint();
+        return delegate.sslSession();
+    }
+
+    @Override
+    public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException {
+        if( isDebugging ) breakpoint();
+        return delegate.peerCertificateChain();
+    }
+
+    @Override
+    public String absoluteURI() {
+        if( isDebugging ) breakpoint();
+        return delegate.absoluteURI();
+    }
+
+    @Override
+    public HttpServerRequest bodyHandler(Handler<Buffer> bodyHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.bodyHandler(bodyHandler);
+    }
+
+    @Override
+    public HttpServerRequest body(Handler<AsyncResult<Buffer>> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.body(handler);
+    }
+
+    @Override
+    public Future<Buffer> body() {
+        if( isDebugging ) breakpoint();
+        return delegate.body();
+    }
+
+    @Override
+    public void end(Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.end(handler);
+    }
+
+    @Override
+    public Future<Void> end() {
+        if( isDebugging ) breakpoint();
+        return delegate.end();
+    }
+
+    @Override
+    public void toNetSocket(Handler<AsyncResult<NetSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toNetSocket(handler);
+    }
+
+    @Override
+    public Future<NetSocket> toNetSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toNetSocket();
+    }
+
+    @Override
+    public HttpServerRequest setExpectMultipart(boolean expect) {
+        if( isDebugging ) breakpoint();
+        return delegate.setExpectMultipart(expect);
+    }
+
+    @Override
+    public boolean isExpectMultipart() {
+        if( isDebugging ) breakpoint();
+        return delegate.isExpectMultipart();
+    }
+
+    @Override
+    public HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.uploadHandler(uploadHandler);
+    }
+
+    @Override
+    public MultiMap formAttributes() {
+        if( isDebugging ) breakpoint();
+        return delegate.formAttributes();
+    }
+
+    @Override
+    public String getFormAttribute(String attributeName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getFormAttribute(attributeName);
+    }
+
+    @Override
+    public int streamId() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamId();
+    }
+
+    @Override
+    public void toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toWebSocket(handler);
+    }
+
+    @Override
+    public Future<ServerWebSocket> toWebSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toWebSocket();
+    }
+
+    @Override
+    public boolean isEnded() {
+        if( isDebugging ) breakpoint();
+        return delegate.isEnded();
+    }
+
+    @Override
+    public HttpServerRequest customFrameHandler(Handler<HttpFrame> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.customFrameHandler(handler);
+    }
+
+    @Override
+    public HttpConnection connection() {
+        if( isDebugging ) breakpoint();
+        return delegate.connection();
+    }
+
+    @Override
+    public StreamPriority streamPriority() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriority();
+    }
+
+    @Override
+    public HttpServerRequest streamPriorityHandler(Handler<StreamPriority> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriorityHandler(handler);
+    }
+
+    @Override
+    public DecoderResult decoderResult() {
+        if( isDebugging ) breakpoint();
+        return delegate.decoderResult();
+    }
+
+    @Override
+    public Cookie getCookie(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name);
+    }
+
+    @Override
+    public Cookie getCookie(String name, String domain, String path) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name, domain, path);
+    }
+
+    @Override
+    public int cookieCount() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieCount();
+    }
+
+    @Override
+    @Deprecated
+    public Map<String, Cookie> cookieMap() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieMap();
+    }
+
+    @Override
+    public Set<Cookie> cookies(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies(name);
+    }
+
+    @Override
+    public Set<Cookie> cookies() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies();
+    }
+
+    @Override
+    public HttpServerRequest routed(String route) {
+        if( isDebugging ) breakpoint();
+        return delegate.routed(route);
+    }
+
+    @Override
+    public Pipe<Buffer> pipe() {
+        if( isDebugging ) breakpoint();
+        return delegate.pipe();
+    }
+
+    @Override
+    public Future<Void> pipeTo(WriteStream<Buffer> dst) {
+        if( isDebugging ) breakpoint();
+        return delegate.pipeTo(dst);
+    }
+
+    @Override
+    public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.pipeTo(dst, handler);
+    }
+
+    @Override
+    public Context context() {
+        if( isDebugging ) breakpoint();
+        return delegate.context();
+    }
+
+    @Override
+    public Object metric() {
+        if( isDebugging ) breakpoint();
+        return delegate.metric();
+    }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java
new file mode 100644
index 0000000..a13a8e2
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java
@@ -0,0 +1,105 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.streams.ReadStream;
+
+import java.util.Set;
+
+public class DelegateVertxHttpServerResponse implements HttpServerResponse {
+
+    private final HttpServerResponse delegate;
+
+    public DelegateVertxHttpServerResponse(HttpServerResponse delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override public HttpServerResponse exceptionHandler(Handler<Throwable> handler) { return delegate.exceptionHandler(handler); }
+    @Override public HttpServerResponse setWriteQueueMaxSize(int maxSize) { return delegate.setWriteQueueMaxSize(maxSize); }
+    @Override public HttpServerResponse drainHandler(Handler<Void> handler) { return delegate.drainHandler(handler); }
+    @Override public int getStatusCode() { return delegate.getStatusCode(); }
+    @Override public HttpServerResponse setStatusCode(int statusCode) { return delegate.setStatusCode(statusCode); }
+    @Override public String getStatusMessage() { return delegate.getStatusMessage(); }
+    @Override public HttpServerResponse setStatusMessage(String statusMessage) { return delegate.setStatusMessage(statusMessage); }
+    @Override public HttpServerResponse setChunked(boolean chunked) { return delegate.setChunked(chunked); }
+    @Override public boolean isChunked() { return delegate.isChunked(); }
+    @Override public MultiMap headers() { return delegate.headers(); }
+    @Override public HttpServerResponse putHeader(String name, String value) { return delegate.putHeader(name, value); }
+    @Override public HttpServerResponse putHeader(CharSequence name, CharSequence value) { return delegate.putHeader(name, value); }
+    @Override public HttpServerResponse putHeader(String name, Iterable<String> values) { return delegate.putHeader(name, values); }
+    @Override public HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values) { return delegate.putHeader(name, values); }
+    @Override public MultiMap trailers() { return delegate.trailers(); }
+    @Override public HttpServerResponse putTrailer(String name, String value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse putTrailer(CharSequence name, CharSequence value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse putTrailer(String name, Iterable<String> values) { return delegate.putTrailer(name, values); }
+    @Override public HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse closeHandler(Handler<Void> handler) { return delegate.closeHandler(handler); }
+    @Override public HttpServerResponse endHandler(Handler<Void> handler) { return delegate.endHandler(handler); }
+    @Override public Future<Void> write(String chunk, String enc) { return delegate.write(chunk, enc); }
+    @Override public void write(String chunk, String enc, Handler<AsyncResult<Void>> handler) { delegate.write(chunk, enc, handler); }
+    @Override public Future<Void> write(String chunk) { return delegate.write(chunk); }
+    @Override public void write(String chunk, Handler<AsyncResult<Void>> handler) { delegate.write(chunk, handler); }
+    @Override public HttpServerResponse writeContinue() { return delegate.writeContinue(); }
+    @Override public Future<Void> end(String chunk) { return delegate.end(chunk); }
+    @Override public void end(String chunk, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, handler); }
+    @Override public Future<Void> end(String chunk, String enc) { return delegate.end(chunk, enc); }
+    @Override public void end(String chunk, String enc, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, enc, handler); }
+    @Override public Future<Void> end(Buffer chunk) { return delegate.end(chunk); }
+    @Override public void end(Buffer chunk, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, handler); }
+    @Override public Future<Void> end() { return delegate.end(); }
+    @Override public void send(Handler<AsyncResult<Void>> handler) { delegate.send(handler); }
+    @Override public Future<Void> send() { return delegate.send(); }
+    @Override public void send(String body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(String body) { return delegate.send(body); }
+    @Override public void send(Buffer body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(Buffer body) { return delegate.send(body); }
+    @Override public void send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(ReadStream<Buffer> body) { return delegate.send(body); }
+    @Override public Future<Void> sendFile(String filename) { return delegate.sendFile(filename); }
+    @Override public Future<Void> sendFile(String filename, long offset) { return delegate.sendFile(filename, offset); }
+    @Override public Future<Void> sendFile(String filename, long offset, long length) { return delegate.sendFile(filename, offset, length); }
+    @Override public HttpServerResponse sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, resultHandler); }
+    @Override public HttpServerResponse sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, offset, resultHandler); }
+    @Override public HttpServerResponse sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, offset, length, resultHandler); }
+    @Override public void close() { delegate.close(); }
+    @Override public boolean ended() { return delegate.ended(); }
+    @Override public boolean closed() { return delegate.closed(); }
+    @Override public boolean headWritten() { return delegate.headWritten(); }
+    @Override public HttpServerResponse headersEndHandler(Handler<Void> handler) { return delegate.headersEndHandler(handler); }
+    @Override public HttpServerResponse bodyEndHandler(Handler<Void> handler) { return delegate.bodyEndHandler(handler); }
+    @Override public long bytesWritten() { return delegate.bytesWritten(); }
+    @Override public int streamId() { return delegate.streamId(); }
+    @Override public HttpServerResponse push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, host, path, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String host, String path) { return delegate.push(method, host, path); }
+    @Override public HttpServerResponse push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, path, headers, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String path, MultiMap headers) { return delegate.push(method, path, headers); }
+    @Override public HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, path, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String path) { return delegate.push(method, path); }
+    @Override public HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, host, path, headers, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String host, String path, MultiMap headers) { return delegate.push(method, host, path, headers); }
+    @Override public boolean reset() { return delegate.reset(); }
+    @Override public boolean reset(long code) { return delegate.reset(code); }
+    @Override public HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload) { return delegate.writeCustomFrame(type, flags, payload); }
+    @Override public HttpServerResponse writeCustomFrame(HttpFrame frame) { return delegate.writeCustomFrame(frame); }
+    @Override public HttpServerResponse setStreamPriority(StreamPriority streamPriority) { return delegate.setStreamPriority(streamPriority); }
+    @Override public HttpServerResponse addCookie(Cookie cookie) { return delegate.addCookie(cookie); }
+    @Override public Cookie removeCookie(String name) { return delegate.removeCookie(name); }
+    @Override public Cookie removeCookie(String name, boolean invalidate) { return delegate.removeCookie(name, invalidate); }
+    @Override public Set<Cookie> removeCookies(String name) { return delegate.removeCookies(name); }
+    @Override public Set<Cookie> removeCookies(String name, boolean invalidate) { return delegate.removeCookies(name, invalidate); }
+    @Override public Cookie removeCookie(String name, String domain, String path) { return delegate.removeCookie(name, domain, path); }
+    @Override public Cookie removeCookie(String name, String domain, String path, boolean invalidate) { return delegate.removeCookie(name, domain, path, invalidate); }
+    @Override public Future<Void> write(Buffer data) { return delegate.write(data); }
+    @Override public void write(Buffer data, Handler<AsyncResult<Void>> handler) { delegate.write(data, handler); }
+    @Override public void end(Handler<AsyncResult<Void>> handler) { delegate.end(handler); }
+    @Override public boolean writeQueueFull() { return delegate.writeQueueFull(); }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java
new file mode 100644
index 0000000..4eb1e20
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java
@@ -0,0 +1,129 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.ext.web.RoutingContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class Foo {
+
+    private static final Logger log = Foo.getLogger(Foo.class);
+    private static final boolean assertRequestEquality = true;
+    private static HttpServerRequest serverInfoRequest;
+    private static io.vertx.core.http.impl.HttpServerRequestInternal restStorageEvBusAdaptMappdHttpServReq;
+    private static long onBeginRouteEpochMs;
+
+    public static synchronized void onNewServerInfoRequst(HttpServerRequest request){
+        if( !isServerInfoRequst(request) ) return;
+        //assert serverInfoRequest == null;
+        log.trace("onNewServerInfoRequst()");
+        serverInfoRequest = request;
+    }
+
+    public static void downReqBegin(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("downReqBegin()");
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void downReqAuthorized(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("downReqAuthorized()");
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void onBeforeMainVerticleRouteGeneric(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("onBeforeMainVerticleRouteGeneric()");
+        onBeginRouteEpochMs = System.currentTimeMillis();
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static Logger getLogger(Class<?> clazz) {
+        assert clazz != null;
+        return getLogger(clazz.getName());
+    }
+
+    public static Logger getLogger(String name) {
+        assert name != null;
+        return LoggerFactory.getLogger("FOO."+ name);
+    }
+
+    public static boolean isServerInfoRequst(HttpServerRequest request) {
+        return isServerInfoRequst(request.uri());
+    }
+
+    private static boolean isServerInfoRequst(String uri) {
+        assert uri != null;
+        assert uri.startsWith("/");
+        try{
+            if( "/houston/server/info".equals(uri) ){
+                //log.trace("true <- isServerInfoRequst({})", uri);
+                return true;
+            }
+            //log.trace("false <- isServerInfoRequst({})", uri);
+            return false;
+        }catch(Throwable ex){
+            assert false;
+            throw ex;
+        }
+    }
+
+    public static void onBeforeEvBusAdapterDataHandler(String uri) {
+        if( !isServerInfoRequst(uri) ) return;
+        log.trace("onBeforeEvBusAdapterDataHandler({})", uri);
+        assert false;
+    }
+
+    public static void onBeforeEvBusAdapterEndHandler(String uri) {
+        if( !isServerInfoRequst(uri)) return;
+        log.trace("onBeforeEvBusAdapterEndHandler({})", uri);
+        assert false;
+    }
+
+    public static void onEvBusAdapterHandle(io.vertx.core.http.impl.HttpServerRequestInternal req) {
+        if( !isServerInfoRequst(req.uri()) ) return;
+        assert !assertRequestEquality || serverInfoRequest != req;
+        assert restStorageEvBusAdaptMappdHttpServReq == null;
+        log.trace("onEvBusAdapterHandle({})", req.uri());
+        restStorageEvBusAdaptMappdHttpServReq = req;
+    }
+
+    public static void onEvBusAdapterError(Throwable ex) {
+        log.error("onEvBusAdapterError()", new Exception("stacktrace", ex));
+    }
+
+    public static void onRestStorageHandlerHandle(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("onRestStorageHandlerHandle({})", req.uri());
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void onRestStorageHandler_getResource(io.vertx.ext.web.RoutingContext ctx) {
+        if( !isServerInfoRequst(ctx.request()) ) return;
+        assert !assertRequestEquality || serverInfoRequest == ctx.request();
+        log.trace("onRestStorageHandler_getResource({})", ctx.request().uri());
+    }
+
+    public static void onRestStorageHandler_getResource_before_storage_get(String path, int offset, int limit) {
+        //log.trace("onRestStorageHandler_getResource_before_storage_get({}, {}, {})", path, offset, limit);
+    }
+
+    public static void onRestStorageHandler_getResource_after_storage_get(String path, int offset, int limit, Object/*org.swisspush.reststorage.Resource*/ resource) {
+        //log.trace("onRestStorageHandler_getResource_after_storage_get({})", path);
+    }
+
+    public static void onGetHoustonServerInfo(RoutingContext ctx) {
+        var req = ctx.request();
+        log.trace("onGetHoustonServerInfo({})", req.uri());
+        assert !assertRequestEquality || serverInfoRequest != req;
+    }
+
+    public static void onEndCompleted(long responseBegEpochMs){
+        long durationMs = System.currentTimeMillis() - responseBegEpochMs;
+        log.debug("Request took {}ms", durationMs);
+    }
+
+}
+
diff --git a/src/main/lua/pcap/KubeProbeFilter.lua b/src/main/lua/pcap/KubeProbeFilter.lua
new file mode 100644
index 0000000..a5967e9
--- /dev/null
+++ b/src/main/lua/pcap/KubeProbeFilter.lua
@@ -0,0 +1,93 @@
+--
+-- Try to extract kube-probe related requests.
+--
+
+local newPcapParser = assert(require("pcapit").newPcapParser)
+local newPcapDumper = assert(require("pcapit").newPcapDumper)
+
+local out, log = io.stdout, io.stderr
+local main, onPcapFrame, vapourizeUrlVariables
+
+
+function onPcapFrame( app, it )
+    local srcPort, dstPort = it:trspSrcPort(), it:trspDstPort()
+    local userAgent, reqUri
+    --
+    if dstPort ~= 7012 and srcPort ~= 7012 then return end
+    local trspPayload = it:trspPayload()
+    local httpReqLinePart1, httpReqLinePart2, httpReqLinePart3 =
+        trspPayload:match("^([A-Z/1.0]+) ([^ ]+) ([^ \r\n]+)\r?\n")
+    if httpReqLinePart1 and not httpReqLinePart1:find("^HTTP/1.%d$") then -- assume HTTP request
+        reqUri = httpReqLinePart2
+        userAgent = trspPayload:match("\n[Uu][Ss][Ee][Rr]%-[Aa][Gg][Ee][Nn][Tt]:%s+([^\r\n]+)\r?\n");
+        if userAgent then
+            --if not userAgent:find("^kube%-probe/") then return end -- assume halfrunt
+            --log:write("User-Agent: ".. userAgent .."\n")
+        end
+    elseif httpReqLinePart1 then -- assume HTTP response
+        --out:write(trspPayload)
+    end
+    local srcIp, dstIp = it:netSrcIpStr(), it:netDstIpStr()
+    local connKey = ((srcPort < dstPort)and(srcPort.."\0"..dstPort)or(dstPort.."\0"..srcPort))
+        .."\0"..((srcIp < dstIp)and(srcIp.."\0"..dstIp)or(dstIp.."\0"..srcIp))
+    local conn = app.connections[connKey]
+    if not conn then conn = {isOfInterest=false, pkgs={}} app.connections[connKey] = conn end
+    conn.isOfInterest = (conn.isOfInterest or reqUri == "/houston/server/info")
+    if not conn.isOfInterest then
+        if #conn.pkgs > 3 then -- Throw away all stuff except TCP handshake
+            conn.pkgs = { conn.pkgs[1], conn.pkgs[2], conn.pkgs[3] }
+        end
+        local sec, usec = it:frameArrivalTime()
+        --for k,v in pairs(getmetatable(it))do print("E",k,v)end
+        local pkg = {
+            sec = assert(sec), usec = assert(usec),
+            caplen = it:frameCaplen(), len = it:frameLen(),
+            tcpFlags = (conn.isOfInterest)and(it:tcpFlags())or false,
+            srcPort = srcPort, dstPort = dstPort,
+            trspPayload = trspPayload,
+            rawFrame = it:rawFrame(),
+        }
+        table.insert(conn.pkgs, pkg)
+    else
+        -- Stop memory hogging. Write that stuff to output
+        if #conn.pkgs > 0 then
+            for _, pkg in ipairs(conn.pkgs) do
+                --out:write(string.format("-- PKG 1  %d->%d  %d.%09d tcpFlg=0x%04X\n", pkg.srcPort, pkg.dstPort, pkg.sec, pkg.usec, pkg.tcpFlags or 0))
+                --out:write(pkg.trspPayload)
+                --out:write("\n")
+                app.dumper:dump(pkg.sec, pkg.usec, pkg.caplen, pkg.len, pkg.rawFrame, 1, pkg.rawFrame:len())
+            end
+            conn.pkgs = {}
+        end
+        local tcpFlags = it:tcpFlags()
+        local sec, usec = it:frameArrivalTime()
+        local rawFrame = it:rawFrame()
+        --out:write(string.format("-- PKG 2  %d->%d  %d.%09d tcpFlg=0x%04X, len=%d\n", srcPort, dstPort, sec, usec, tcpFlags or 0, trspPayload:len()))
+        --out:write(trspPayload)
+        --if trspPayload:byte(trspPayload:len()) ~= 0x0A then out:write("\n") end
+        --out:write("\n")
+        app.dumper:dump(sec, usec, it:frameCaplen(), it:frameLen(), rawFrame, 1, rawFrame:len())
+    end
+end
+
+
+function main()
+    local app = {
+        parser = false,
+        dumper = false,
+        connections = {},
+    }
+    app.parser = newPcapParser{
+        dumpFilePath = "-",
+        onFrame = function(f)onPcapFrame(app, f)end,
+    }
+    app.dumper = newPcapDumper{
+        dumpFilePath = "C:/work/tmp/KubeProbeFilter.out.pcap",
+    }
+    app.parser:resume()
+end
+
+
+main()
+
+
diff --git a/src/main/lua/wireshark/HttpTime.lua b/src/main/lua/wireshark/HttpTime.lua
index b06c0a7..514c62b 100644
--- a/src/main/lua/wireshark/HttpTime.lua
+++ b/src/main/lua/wireshark/HttpTime.lua
@@ -10,7 +10,7 @@ local mod = {}
 
 function mod.init()
     local that = mod.seal{
-        proto = Proto("__", "Additional Metadata"),
+        proto = Proto("AdditMeta", "Additional Metadata"),
         f_andy_httpTime = ProtoField.float("_.httpTime", "HttpTime"),
         f_andy_synSeen = ProtoField.bool("_.synSeen", "SynSeen"),
         f_andy_uri = ProtoField.string("_.uri", "Request URI"),