Dashboard stops updating after runtime error

[dlhall111]

Since updating to 1.0.6 (including adding resource limits, as recommended) I'm seeing the following errors logged in the backend after a few hours of uptime:

2025/08/04 16:22:50 Panic in pollLoop: runtime error: slice bounds out of range [8700:5800]
2025/08/04 16:22:50 Panic in watchLoop: runtime error: slice bounds out of range [8700:5800]

Once these errors are thrown the dashboard no longer updates but the frontend/backend service continue to run and the dashboard is still accessible.

Simply restarting the backend service restores normal operations.

Note: I'm using Beszel for docker resource monitoring and don't see any unusual resource usage from the backend service (or the frontend) at the timeframe that the runtime error is logged. Memory and CPU usage is consistent before/after the error is logged.

[hhftechnology]

try latest 1.0.7

[dlhall111]

@hhftechnology I updated earlier today and will monitor for new occurrences and reopen if needed. Thanks!

[dlhall111]

@hhftechnology it happened just a few minutes after I typed the above... :/

2025/08/05 15:53:59 Panic in pollLoop: runtime error: slice bounds out of range [:116588] with capacity 65536
2025/08/05 15:53:59 Panic in watchLoop: runtime error: slice bounds out of range [:116588] with capacity 65536

[hhftechnology]

share your compose file, OS version and traefik version

[dlhall111]

@hhftechnology here's my compose (redacted where needed):

services:
  backend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-backend:latest
    container_name: log-dashboard-backend
    restart: unless-stopped
    volumes:
      - /path/traefik/logs:/logs:ro # Mount the Traefik logs directory
      - ./maxmind:/maxmind
    environment:
      - NODE_ENV=production
      - TRAEFIK_LOG_FILE=/logs/access.log
      - PORT=3002
      - USE_MAXMIND=true
      - MAXMIND_DB_PATH=/maxmind/GeoLite2-City.mmdb
      - MAXMIND_FALLBACK_ONLINE=true
      - MAXMIND_LICENSE_KEY=apikey
      - GOGC=50
      - GOMEMLIMIT=500MiB
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
        reservations:
          cpus: '0.25'
          memory: 128M
    networks:
      - pangolin
  frontend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-frontend:latest
    container_name: log-dashboard-frontend
    restart: unless-stopped
    environment:
      - BACKEND_PORT=3002
    depends_on:
      - backend
    deploy:
      resources:
        limits:
          cpus: '0.25'
          memory: 128M
        reservations:
          cpus: '0.1'
          memory: 64M
    networks:
      - pangolin

networks:
  pangolin:
    name: pangolin
    external: true

This is running in Docker 28.3.3 on Debian 12.2.0 with Traefik 3.5.0.

[hhftechnology]

services:
  backend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-backend:1.0.7
    container_name: log-dashboard-backend
    restart: unless-stopped
    volumes:
      - /path/traefik/logs:/logs:ro # Mount the Traefik logs directory
      - ./maxmind:/maxmind
    environment:
      - TRAEFIK_LOG_FILE=/logs/access.log
      - USE_MAXMIND=true
      - MAXMIND_DB_PATH=/maxmind/GeoLite2-City.mmdb
      - MAXMIND_FALLBACK_ONLINE=true
      - GOGC=50
      - GOMEMLIMIT=500MiB
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
        reservations:
          cpus: '0.25'
          memory: 128M

  frontend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-frontend:l1.0.7
    container_name: log-dashboard-frontend
    restart: unless-stopped
    depends_on:
      - backend
    deploy:
      resources:
        limits:
          cpus: '0.25'
          memory: 128M
        reservations:
          cpus: '0.1'
          memory: 64M

networks:
  pangolin:
    name: pangolin
    external: true

Use this as it is. In target user private ip of the VPS/VM

[dlhall111]

@hhftechnology I had to re-add the "networks: pangolin" lines to frontend/backend otherwise it wasn't reachable + had to use "latest" tag since I couldn't pull it using "1.0.7" tag (it throws "manifest unknown"), but am now running it as you suggested otherwise:

services:
  backend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-backend:latest
    container_name: log-dashboard-backend
    restart: unless-stopped
    volumes:
      - /path/traefik/logs:/logs:ro # Mount the Traefik logs directory
      - ./maxmind:/maxmind
    environment:
      - TRAEFIK_LOG_FILE=/logs/access.log
      - USE_MAXMIND=true
      - MAXMIND_DB_PATH=/maxmind/GeoLite2-City.mmdb
      - MAXMIND_FALLBACK_ONLINE=true
      - GOGC=50
      - GOMEMLIMIT=500MiB
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
        reservations:
          cpus: '0.25'
          memory: 128M
    networks:
      - pangolin

  frontend:
    image: ghcr.io/hhftechnology/traefik-log-dashboard-frontend:latest
    container_name: log-dashboard-frontend
    restart: unless-stopped
    depends_on:
      - backend
    deploy:
      resources:
        limits:
          cpus: '0.25'
          memory: 128M
        reservations:
          cpus: '0.1'
          memory: 64M
    networks:
      - pangolin

networks:
  pangolin:
    name: pangolin
    external: true

[dlhall111]

@hhftechnology not sure if this is any way related to the original issue, but I just had a crash with this exception (using the above compose):

fatal error: concurrent map iteration and map write
goroutine 57 [running]:
reflect.mapiternext(0x4ad8a9?)
  /usr/local/go/src/runtime/map.go:1397 +0x13
reflect.(*MapIter).Next(0xc000344d68?)
  /usr/local/go/src/reflect/value.go:2005 +0x74
encoding/json.mapEncoder.encode({0x40?}, 0xc0004d0080, {0x81b580?, 0xc0003d4068?, 0x2?}, {0xc?, 0x0?})
  /usr/local/go/src/encoding/json/encode.go:745 +0x334
encoding/json.structEncoder.encode({{{0xc00059d308, 0x15, 0x23}, 0xc0000897d0, 0xc000089920}}, 0xc0004d0080, {0x8868a0?, 0xc0003d4000?, 0xc0004d0070?}, {0x0, ...})
  /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.ptrEncoder.encode({0xc0004d0070?}, 0xc0004d0080, {0x7f2360?, 0xc0004d0070?, 0xc0004d0070?}, {0x8?, 0x0?})
  /usr/local/go/src/encoding/json/encode.go:876 +0x23c
encoding/json.structEncoder.encode({{{0xc000119208, 0x4, 0x4}, 0xc00023c0c0, 0xc00023c150}}, 0xc0004d0080, {0x85d0e0?, 0xc0004d0040?, 0x40e61b?}, {0x0, ...})
  /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.(*encodeState).reflectValue(0xc0004d0080, {0x85d0e0?, 0xc0004d0040?, 0x40e9c5?}, {0x38?, 0x0?})
  /usr/local/go/src/encoding/json/encode.go:321 +0x73
encoding/json.(*encodeState).marshal(0x40e785?, {0x85d0e0?, 0xc0004d0040?}, {0x40?, 0xf6?})
  /usr/local/go/src/encoding/json/encode.go:297 +0xc5
encoding/json.Marshal({0x85d0e0, 0xc0004d0040})
  /usr/local/go/src/encoding/json/encode.go:163 +0xd0
main.(*WebSocketClient).sendMessage(0xc0002b4cb0, {{0x89e04d, 0x6}, {0x8921a0, 0xc0003dc008}, {0x0, 0x0}, 0xc0003d4000})
  /app/websocket.go:290 +0x10c
main.(*WebSocketClient).sendNewLogWithStats(_, {{0xc0004066d8, 0x18}, {0xc000464d60, 0x19}, {0xc0003f9800, 0xb}, {0xc000403438, 0x3}, {0xc00044eaf0, ...}, ...})
  /app/websocket.go:359 +0x310
main.(*WebSocketClient).WritePump(0xc0002b4cb0)
  /app/websocket.go:193 +0x745
main.(*WebSocketClient).Start.func1()
  /app/websocket.go:57 +0x49
created by main.(*WebSocketClient).Start in goroutine 55
  /app/websocket.go:49 +0x56
goroutine 1 [chan receive, 91 minutes]:
main.main()
  /app/main.go:138 +0xbc5
goroutine 6 [select, 91 minutes]:
github.com/patrickmn/go-cache.(*janitor).Run(0xc0000858d0, 0xc000286240)
  /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1079 +0x7d
created by github.com/patrickmn/go-cache.runJanitor in goroutine 1
  /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1099 +0xdb
goroutine 7 [select, 2 minutes]:
main.startRetryProcessor.func1()
  /app/geoLocation.go:585 +0x5a
created by main.startRetryProcessor in goroutine 1
  /app/geoLocation.go:583 +0x4c
goroutine 9 [syscall, 91 minutes]:
os/signal.signal_recv()
  /usr/local/go/src/runtime/sigqueue.go:152 +0x29
os/signal.loop()
  /usr/local/go/src/os/signal/signal_unix.go:23 +0x13
created by os/signal.Notify.func1.1 in goroutine 1
  /usr/local/go/src/os/signal/signal.go:151 +0x1f
goroutine 19 [chan receive, 91 minutes]:
main.main.func1()
  /app/main.go:52 +0x26
created by main.main in goroutine 1
  /app/main.go:51 +0x16c
goroutine 20 [select]:
main.startWebSocketHealthMonitor.func1()
  /app/main.go:238 +0x71
created by main.startWebSocketHealthMonitor in goroutine 1
  /app/main.go:236 +0x7d
goroutine 22 [IO wait]:
internal/poll.runtime_pollWait(0x7fd0926f1e40, 0x72)
  /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x3?, 0x1?, 0x0)
  /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
  /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc0000fe080)
  /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc0000fe080)
  /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc00006a360)
  /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc00006a360)
  /usr/local/go/src/net/tcpsock.go:327 +0x30
net/http.(*Server).Serve(0xc000270000, {0x9649f0, 0xc00006a360})
  /usr/local/go/src/net/http/server.go:3260 +0x33e
net/http.(*Server).ListenAndServe(0xc000270000)
  /usr/local/go/src/net/http/server.go:3189 +0x71
main.main.func2()
  /app/main.go:132 +0x1b
created by main.main in goroutine 1
  /app/main.go:131 +0xba7
goroutine 10 [select]:
github.com/fsnotify/fsnotify.(*Watcher).sendEvent(...)
  /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:276
github.com/fsnotify/fsnotify.(*Watcher).readEvents(0xc000286280)
  /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:564 +0x7ca
created by github.com/fsnotify/fsnotify.NewBufferedWatcher in goroutine 21
  /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:270 +0x1c5

[dlhall111]

@hhftechnology I am able to reproduce this crash, sort of. At the time the crash occurred I was navigating around Jellyseerr so I went back and did some more navigating around Jellyseerr while viewing the frontend page and after maybe 20-30 seconds of loading different things in Jellyseerr (which was of course causing a LOT of URL hits to spin through the live logging) it hit this same crash again.

My assumption is that this is an issue with updating the frontend when a lot of rapid logging activity is occurring. For example, loading just the home (Discover) page of Jellyseerr results in about 150 log entries (most of that is the image loading).

Edit: I cannot reproduce any crash if I'm not actively accessing the frontend when I'm loading/refreshing Jellyseerr.

[hhftechnology]

currently i am running the dashboard with 12000K entries. no crash v1.0.7

[dlhall111]

@hhftechnology I'm not referring to the total number of accumulated requests, I'm referring to a high frequency of requests in a short time. This app is running at 15K accumulated requests at the moment with no issue... but I bring up the frontend page and am viewing the live log and then open Jellyseerr in another browser that burst of 100-150 updates to the live log is what I see at the point of the crash occurring and that's something I can consistently reproduce.

Let me know if you have any questions or need more info, or if you'd like a separate bug filed for this new crash scenario (haven't seen the original panic errors since deploying the updated compose you suggested).

[dlhall111]

@hhftechnology just had another occurrence of the original issue:

2025/08/07 14:59:42 Panic in watchLoop: runtime error: slice bounds out of range [:112715] with capacity 65536
2025/08/07 14:59:42 Panic in pollLoop: runtime error: slice bounds out of range [:112715] with capacity 65536

15,532 requests accumulated with an uptime of a little over 12 hours.

[hhftechnology]

log ingest is only 1000, i now reduced to 500

[dlhall111]

@hhftechnology will you be updating the pre-built images with these latest changes? I'm using ghcr.io/hhftechnology/traefik-log-dashboard-backend and ghcr.io/hhftechnology/traefik-log-dashboard-frontend images at the moment but they haven't gotten the latest updates it looks like.

I still see the original issue (panic error, no more updating) about once or twice a day and can still reproduce the crash issue when loading Jellyseerr while viewing the frontend.

[dlhall111]

@hhftechnology I switched from the GitHub image to Docker Hub image to get up-to-date but can still reproduce both the "concurrent map iteration and map write" crash (when refreshing Jellyseerr a few times) and the "Panic in watchLoop/Panic in pollLoop" runtime errors that cease all updates until the backend is restarted.

[dlhall111]

@hhftechnology I switched to using the OTLP config earlier today and haven't had any occurrences of the runtime error or the backend crash when refreshing Jellyseerr since then (yay!). However, I'm no longer getting any size information in the logs and the "Data Transmitted" section in the header is always "0 B" of course. I've been looking at how to maybe get this added via changes to the Traefik config.yml but so far I'm not seeing it... any idea on how to get sizes added to the OTLP output? Thanks!

Edit: Unfortunately I was able to reproduce the "fatal error: concurrent map iteration and map write" backend crash while scrolling through the "Movies" section of Jellyseerr (where it's loading tons of images very fast)... this is with the sampleRate set to "1.0" (I had started out with "0.1" and increased in stages to see how it performed). I'll set sampleRate back down a bit and see if the crash still occurs.

[AsDinFlames]

Hey
i gonna face the same issue right now. I used the dockerhub container and since this version was updated 4 month ago i created also the docker images from repository. I cant make it past then 2.000 entries. The backend services crashed cause of the same "map"-reason. And yes it's not crashing if the frontend is stopped.

My traefik+crowdsec handles like 20 services and it takes like 5-10minutes to get past 2.000 entries.

In another issue posted here it was recommended to use "sample rate" to 0.1 as a workaround to get not that much crashed but i dont know where to set it.

Is this an issue you will and can fix in the future? Since your dashboard is by far the only and best nice looking dashboard i found which is leightweight whats important for me.

[plakun]

Hello, have the same issue, use latest docker-compose base from github main-branch.
After start service collects initial data and after few seconds backend shows error:

2025/09/05 06:02:37 [OTLP] Converted span 'EntryPoint' to log entry: POST /api/v1/osquery/config 200 (5.03ms)
fatal error: concurrent map iteration and map write

goroutine 174 [running]:
reflect.mapiternext(0x4befc9?)
        /usr/local/go/src/runtime/map.go:1397 +0x13
reflect.(*MapIter).Next(0xc0004a4cf0?)
        /usr/local/go/src/reflect/value.go:2005 +0x74
encoding/json.mapEncoder.encode({0xc0004a4e50?}, 0xc000314040, {0xc9bec0?, 0xc0001e23d8?, 0x2?}, {0xa?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:745 +0x334
encoding/json.structEncoder.encode({{{0xc0000f2c08, 0x18, 0x23}, 0xc000250f90, 0xc000250fc0}}, 0xc000314040, {0xd89d80?, 0xc0001e23c0?, 0xc000314030?}, {0x0, ...})
        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.ptrEncoder.encode({0xc000314030?}, 0xc000314040, {0xc407e0?, 0xc000314030?, 0xc000314030?}, {0x8?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:876 +0x23c
encoding/json.structEncoder.encode({{{0xc0000e2008, 0x4, 0x4}, 0xc00032f170, 0xc00032f1a0}}, 0xc000314040, {0xd25900?, 0xc000314000?, 0x411b1b?}, {0x0, ...})
        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.(*encodeState).reflectValue(0xc000314040, {0xd25900?, 0xc000314000?, 0x411ec5?}, {0x38?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:321 +0x73
encoding/json.(*encodeState).marshal(0x411c85?, {0xd25900?, 0xc000314000?}, {0x5f?, 0x1?})
        /usr/local/go/src/encoding/json/encode.go:297 +0xc5
encoding/json.Marshal({0xd25900, 0xc000314000})
        /usr/local/go/src/encoding/json/encode.go:163 +0xd0
main.(*WebSocketClient).sendMessage(0xc000398000, {{0xda70f9, 0x6}, {0xd9a220, 0xc0002fcc88}, {0x0, 0x0}, 0xc0001e23c0})
        /app/websocket.go:290 +0x10c
main.(*WebSocketClient).sendNewLogWithStats(_, {{0xc000490738, 0x15}, {0xc000490750, 0x14}, {0xc0003fbd10, 0xd}, {0xc0003fbc68, 0x4}, {0xc0003fc9c0, ...}, ...})
        /app/websocket.go:359 +0x32a
main.(*WebSocketClient).WritePump(0xc000398000)
        /app/websocket.go:193 +0x745
main.(*WebSocketClient).Start.func1()
        /app/websocket.go:57 +0x49
created by main.(*WebSocketClient).Start in goroutine 172
        /app/websocket.go:49 +0x56

goroutine 1 [chan receive, 4 minutes]:
main.main()
        /app/main.go:169 +0x1398

goroutine 8 [select, 4 minutes]:
github.com/patrickmn/go-cache.(*janitor).Run(0xc0001e1e30, 0xc00039f580)
        /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1079 +0x7d
created by github.com/patrickmn/go-cache.runJanitor in goroutine 1
        /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1099 +0xdb

goroutine 9 [select, 1 minutes]:
main.startRetryProcessor.func1()
        /app/geoLocation.go:585 +0x5a
created by main.startRetryProcessor in goroutine 1
        /app/geoLocation.go:583 +0x4c

goroutine 10 [IO wait, 4 minutes]:
internal/poll.runtime_pollWait(0x7f99e6ec9eb0, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x3?, 0x1?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc000304f80)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc000304f80)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc000308460)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc000308460)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
google.golang.org/grpc.(*Server).Serve(0xc0002f4600, {0xeefff8, 0xc000308460})
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/server.go:871 +0x469
main.(*OTLPReceiver).startGRPCServer.func1()
        /app/otlp.go:154 +0x26
created by main.(*OTLPReceiver).startGRPCServer in goroutine 1
        /app/otlp.go:153 +0x148

goroutine 11 [IO wait, 1 minutes]:
internal/poll.runtime_pollWait(0x7f99e6ec9db8, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x7?, 0x1?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc0002da300)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc0002da300)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc000312000)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc000312000)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
net/http.(*Server).Serve(0xc0003b25a0, {0xeefff8, 0xc000312000})
        /usr/local/go/src/net/http/server.go:3260 +0x33e
net/http.(*Server).ListenAndServe(0xc0003b25a0)
        /usr/local/go/src/net/http/server.go:3189 +0x71
main.(*OTLPReceiver).startHTTPServer.func1()
        /app/otlp.go:177 +0x1f
created by main.(*OTLPReceiver).startHTTPServer in goroutine 1
        /app/otlp.go:176 +0x28d

goroutine 33 [syscall, 4 minutes]:
os/signal.signal_recv()
        /usr/local/go/src/runtime/sigqueue.go:152 +0x29
os/signal.loop()
        /usr/local/go/src/os/signal/signal_unix.go:23 +0x13
created by os/signal.Notify.func1.1 in goroutine 1
        /usr/local/go/src/os/signal/signal.go:151 +0x1f

goroutine 34 [chan receive, 4 minutes]:
main.main.func1()
        /app/main.go:67 +0x26
created by main.main in goroutine 1
        /app/main.go:66 +0x513

goroutine 35 [select, 1 minutes]:
main.startWebSocketHealthMonitor.func1()
        /app/main.go:275 +0x71
created by main.startWebSocketHealthMonitor in goroutine 1
        /app/main.go:273 +0x7d

goroutine 37 [IO wait]:
internal/poll.runtime_pollWait(0x7f99e6ec9cc0, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x8?, 0x426f65?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc0002da380)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc0002da380)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc000312040)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc000312040)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
net/http.(*Server).Serve(0xc0000361e0, {0xeefff8, 0xc000312040})
        /usr/local/go/src/net/http/server.go:3260 +0x33e
net/http.(*Server).ListenAndServe(0xc0000361e0)
        /usr/local/go/src/net/http/server.go:3189 +0x71
main.main.func2()
        /app/main.go:163 +0x1b
created by main.main in goroutine 1
        /app/main.go:162 +0x137b

goroutine 141 [runnable]:
main.(*LogParser).processLogEntry(0xc0002fca08, 0xc0004991f8, 0x1)
        /app/logParser.go:657 +0x23a
main.(*LogParser).ProcessOTLPLogEntry(_, {{0xc000490138, 0x15}, {0xc000490150, 0x14}, {0xc0003fbe90, 0xd}, {0xc0003fbde8, 0x4}, {0xc0003fcaf8, ...}, ...})
        /app/logParser.go:635 +0x75
main.(*OTLPReceiver).processOTLPSpans(0xc0001166c0, {0xc0002220c0?, 0xc000502b48?})
        /app/otlp.go:340 +0x318
main.(*OTLPReceiver).processOTLPProtobuf(0xc0001166c0, {0x0?, 0xdb8e91?}, {0xc0004f0000?, 0xc0003faba0?, 0x4?})
        /app/otlp.go:309 +0x21c
main.(*OTLPReceiver).handleHTTPTraces(0xc0001166c0, {0xef0298, 0xc00032c0e0}, 0xc000200900)
        /app/otlp.go:257 +0x805
net/http.HandlerFunc.ServeHTTP(0xc0000964e0?, {0xef0298?, 0xc00032c0e0?}, 0xdbeffb?)
        /usr/local/go/src/net/http/server.go:2171 +0x29
net/http.(*ServeMux).ServeHTTP(0xc0002504e0?, {0xef0298, 0xc00032c0e0}, 0xc000200900)
        /usr/local/go/src/net/http/server.go:2688 +0x1ad
main.(*OTLPReceiver).startHTTPServer.(*OTLPReceiver).corsMiddleware.func2({0xef0298, 0xc00032c0e0}, 0xc000200900)
        /app/otlp.go:197 +0x10d
net/http.HandlerFunc.ServeHTTP(0x411ec5?, {0xef0298?, 0xc00032c0e0?}, 0xc00032c001?)
        /usr/local/go/src/net/http/server.go:2171 +0x29
net/http.serverHandler.ServeHTTP({0xeed670?}, {0xef0298?, 0xc00032c0e0?}, 0x6?)
        /usr/local/go/src/net/http/server.go:3142 +0x8e
net/http.(*conn).serve(0xc0002d0630, {0xef2c18, 0xc00032e150})
        /usr/local/go/src/net/http/server.go:2044 +0x5e8
created by net/http.(*Server).Serve in goroutine 11
        /usr/local/go/src/net/http/server.go:3290 +0x4b4

goroutine 175 [IO wait]:
internal/poll.runtime_pollWait(0x7f99e6ec9bc8, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0xc0002da000?, 0xc00009ac00?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Read(0xc0002da000, {0xc00009ac00, 0x400, 0x400})
        /usr/local/go/src/internal/poll/fd_unix.go:164 +0x27a
net.(*netFD).Read(0xc0002da000, {0xc00009ac00?, 0x0?, 0x0?})
        /usr/local/go/src/net/fd_posix.go:55 +0x25
net.(*conn).Read(0xc000060000, {0xc00009ac00?, 0xc000400c60?, 0x45c93e?})
        /usr/local/go/src/net/net.go:185 +0x45
bufio.(*Reader).fill(0xc000366420)
        /usr/local/go/src/bufio/bufio.go:110 +0x103
bufio.(*Reader).Peek(0xc000366420, 0x2)
        /usr/local/go/src/bufio/bufio.go:148 +0x53
github.com/gorilla/websocket.(*Conn).read(0xc00048c580, 0x7f99e6ec9cb8?)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:378 +0x26
github.com/gorilla/websocket.(*Conn).advanceFrame(0xc00048c580)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:824 +0x6d
github.com/gorilla/websocket.(*Conn).NextReader(0xc00048c580)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:1034 +0x13e
github.com/gorilla/websocket.(*Conn).ReadMessage(0xc226bd2d41aceb63?)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:1120 +0x13
main.(*WebSocketClient).ReadPump(0xc000398000)
        /app/websocket.go:108 +0x167
main.(*WebSocketClient).Start.func2()
        /app/websocket.go:68 +0x49
created by main.(*WebSocketClient).Start in goroutine 172
        /app/websocket.go:60 +0x96

goroutine 152 [IO wait]:
internal/poll.runtime_pollWait(0x7f99e6ec9ad0, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0xc0002da580?, 0xc0001dbcf1?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Read(0xc0002da580, {0xc0001dbcf1, 0x1, 0x1})
        /usr/local/go/src/internal/poll/fd_unix.go:164 +0x27a
net.(*netFD).Read(0xc0002da580, {0xc0001dbcf1?, 0xc000404f48?, 0x46de90?})
        /usr/local/go/src/net/fd_posix.go:55 +0x25
net.(*conn).Read(0xc0002de020, {0xc0001dbcf1?, 0x1?, 0x155f0c0?})
        /usr/local/go/src/net/net.go:185 +0x45
net/http.(*connReader).backgroundRead(0xc0001dbce0)
        /usr/local/go/src/net/http/server.go:681 +0x37
created by net/http.(*connReader).startBackgroundRead in goroutine 141
        /usr/local/go/src/net/http/server.go:677 +0xba
2025/09/05 06:02:38 OTLP receiver initialized - GRPC:4317, HTTP:4318
2025/09/05 06:02:38 [OTLP] Starting OTLP receiver - GRPC:4317, HTTP:4318
2025/09/05 06:02:38 [OTLP] GRPC trace service registered (placeholder implementation)
2025/09/05 06:02:38 [OTLP] GRPC server listening on :4317
2025/09/05 06:02:38 [OTLP] HTTP server listening on :4318
2025/09/05 06:02:38 [OTLP] OTLP receiver started successfully
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /api/stats                --> main.getStats (4 handlers)
[GIN-debug] GET    /api/logs                 --> main.getLogs (4 handlers)
[GIN-debug] GET    /api/services             --> main.getServices (4 handlers)
[GIN-debug] GET    /api/routers              --> main.getRouters (4 handlers)
[GIN-debug] GET    /api/geo-stats            --> main.getGeoStats (4 handlers)
[GIN-debug] GET    /api/geo-processing-status --> main.getGeoProcessingStatus (4 handlers)
[GIN-debug] POST   /api/set-log-file         --> main.setLogFile (4 handlers)
[GIN-debug] POST   /api/set-log-files        --> main.setLogFiles (4 handlers)
[GIN-debug] GET    /api/otlp/status          --> main.getOTLPStatus (4 handlers)
[GIN-debug] POST   /api/otlp/start           --> main.startOTLPReceiver (4 handlers)
[GIN-debug] POST   /api/otlp/stop            --> main.stopOTLPReceiver (4 handlers)
[GIN-debug] GET    /api/otlp/stats           --> main.getOTLPStats (4 handlers)
[GIN-debug] GET    /api/maxmind/config       --> main.getMaxMindConfig (4 handlers)
[GIN-debug] POST   /api/maxmind/reload       --> main.reloadMaxMindDatabase (4 handlers)
[GIN-debug] POST   /api/maxmind/test         --> main.testMaxMindDatabase (4 handlers)
[GIN-debug] GET    /api/websocket/status     --> main.getWebSocketStatus (4 handlers)
[GIN-debug] GET    /health                   --> main.healthCheck (4 handlers)
[GIN-debug] GET    /ws                       --> main.handleWebSocket (4 handlers)
2025/09/05 06:02:38 Setting up log file monitoring for: /logs/access.log
2025/09/05 06:02:38 Server running on port 3001
2025/09/05 06:02:38 MaxMind configuration: {Enabled:false DatabasePath:/maxmind/GeoLite2-City.mmdb FallbackToOnline:true DatabaseLoaded:false DatabaseError:}
2025/09/05 06:02:38 OTLP configuration: {Enabled:true GRPCPort:4317 HTTPPort:4318 GRPCAddr:0.0.0.0:4317 HTTPAddr:0.0.0.0:4318}
2025/09/05 06:02:38 WebSocket clients tracking enabled
2025/09/05 06:02:38 Setting up monitoring for 1 log path(s)
2025/09/05 06:02:38 Warning: Path /logs/access.log does not exist: stat /logs/access.log: no such file or directory
[GIN] 2025/09/05 - 06:02:38 | 200 |     102.584µs |             ::1 | GET      "/health"
2025/09/05 06:02:42 [OTLP] Received HTTP trace request from 10.249.207.231:52510, Content-Type: application/x-protobuf, Content-Encoding: gzip, Content-Length:
2025/09/05 06:02:42 [OTLP] Received 3331 bytes of trace data
2025/09/05 06:02:42 [OTLP] Decompressed 3331 bytes to 23858 bytes
2025/09/05 06:02:42 [OTLP] Successfully parsed 1 resource spans

[ovizii]

Using image: ghcr.io/hhftechnology/traefik-log-dashboard-backend:latest and image: ghcr.io/hhftechnology/traefik-log-dashboard-frontend:latest I am getting something similar, the errors start after finally getting this app up and running for like 10 minutes or so, then it starts with:

log-dashboard-backend  | 2025/09/09 19:52:48 WebSocket clients tracking enabled
log-dashboard-backend  | 2025/09/09 19:52:49 Loading last 1000 log entries from /logs/traefik-access.log
log-dashboard-backend  | 2025/09/09 19:52:49 Starting background geo processing...
log-dashboard-backend  | 2025/09/09 19:52:49 Processed geo data for 6 IPs. 0 IPs remaining in queue.
.
.
.
log-dashboard-backend  | 2025/09/09 20:11:40 [WebSocket] Sending initial data to client 20250909-201140-172.16.34.3:36438
log-dashboard-backend  | 2025/09/09 20:11:40 [WebSocket] Sending initial stats to client 20250909-201140-172.16.34.3:36438
log-dashboard-backend  | [GIN] 2025/09/09 - 20:11:40 | 200 |     212.467µs |  100.104.120.16 | GET      "/ws"
log-dashboard-backend  | 2025/09/09 20:11:40 [WebSocket] Sending 1000 initial logs to client 20250909-201140-172.16.34.3:36438
log-dashboard-backend  | 2025/09/09 20:11:40 [WebSocket] Client 20250909-201140-172.16.34.3:36438 subscribed to log updates
log-dashboard-backend  | 2025/09/09 20:11:48 [WebSocket] Health check: 1 clients healthy
log-dashboard-backend  | 2025/09/09 20:12:18 [WebSocket] Health check: 1 clients healthy
log-dashboard-backend  | 2025/09/09 20:12:48 [WebSocket] Health check: 1 clients healthy
log-dashboard-backend  | 2025/09/09 20:13:18 [WebSocket] Health check: 1 clients healthy
log-dashboard-backend  | fatal error: concurrent map iteration and map write

followed by lots of this and more. Not sure how useful it is to post it all here.

og-dashboard-backend  | goroutine 99 [running]:
log-dashboard-backend  | reflect.mapiternext(0x4ad8a9?)
log-dashboard-backend  |        /usr/local/go/src/runtime/map.go:1397 +0x13
log-dashboard-backend  | reflect.(*MapIter).Next(0xc00055cd68?)
log-dashboard-backend  |        /usr/local/go/src/reflect/value.go:2005 +0x74
log-dashboard-backend  | encoding/json.mapEncoder.encode({0xc0000121e0?}, 0xc00024a040, {0x81b580?, 0xc000310018?, 0x2?}, {0xa?, 0x0?})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:745 +0x334
log-dashboard-backend  | encoding/json.structEncoder.encode({{{0xc000222008, 0x15, 0x23}, 0xc0004485d0, 0xc000448600}}, 0xc00024a040, {0x8868a0?, 0xc000310000?, 0xc00024a0b0?}, {0x0, ...})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
log-dashboard-backend  | encoding/json.ptrEncoder.encode({0xc00024a0b0?}, 0xc00024a040, {0x7f2360?, 0xc00024a0b0?, 0xc00024a0b0?}, {0x8?, 0x0?})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:876 +0x23c
log-dashboard-backend  | encoding/json.structEncoder.encode({{{0xc000164908, 0x4, 0x4}, 0xc000448690, 0xc0004486c0}}, 0xc00024a040, {0x85d0e0?, 0xc00024a080?, 0xc0000aa210?}, {0x0, ...})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
log-dashboard-backend  | encoding/json.(*encodeState).reflectValue(0xc00024a040, {0x85d0e0?, 0xc00024a080?, 0xc00055d2d0?}, {0xa0?, 0x4f?})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:321 +0x73
log-dashboard-backend  | encoding/json.(*encodeState).marshal(0x40e61b?, {0x85d0e0?, 0xc00024a080?}, {0x0?, 0x0?})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:297 +0xc5
log-dashboard-backend  | encoding/json.Marshal({0x85d0e0, 0xc00024a080})
log-dashboard-backend  |        /usr/local/go/src/encoding/json/encode.go:163 +0xd0
log-dashboard-backend  | main.(*WebSocketClient).sendMessage(0xc0001f29a0, {{0x89e04d, 0x6}, {0x8921a0, 0xc0002ebb88}, {0x0, 0x0}, 0xc000310000})
log-dashboard-backend  |        /app/websocket.go:290 +0x10c
log-dashboard-backend  | main.(*WebSocketClient).sendNewLogWithStats(_, {{0xc0004a1d28, 0x18}, {0xc0003e0380, 0x19}, {0xc00049e0d8, 0xb}, {0xc0002abdd8, 0x3}, {0xc0008a7dc0, ...}, ...})
log-dashboard-backend  |        /app/websocket.go:359 +0x310
log-dashboard-backend  | main.(*WebSocketClient).WritePump(0xc0001f29a0)
log-dashboard-backend  |        /app/websocket.go:193 +0x745
log-dashboard-backend  | main.(*WebSocketClient).Start.func1()
log-dashboard-backend  |        /app/websocket.go:57 +0x49
log-dashboard-backend  | created by main.(*WebSocketClient).Start in goroutine 97
log-dashboard-backend  |        /app/websocket.go:49 +0x56

[ovizii]

I am getting something similar, the errors start after finally getting this app up and running for like 10 minutes or so, then it starts with:

log-dashboard-backend  | fatal error: concurrent map iteration and map write

I just managed to trigger this error by accessing Plex which is behind traefik by browsing some big libraries.

[milindpatel63]

I can reproduce this too. As reported by everyone else, it happens when a burst of request come.
Whenever i browse my immich photo library, it sends a lot of request in a very short time, which crashes the backend with the following log

2025/09/20 03:46:53 [WebSocket] Client 20250920-034511-127.0.0.1:11398 sent 100 messages
2025/09/20 03:46:55 [WebSocket] Client 20250920-034511-127.0.0.1:11398 sent 200 messages
2025/09/20 03:46:57 [WebSocket] Client 20250920-034511-127.0.0.1:11398 sent 400 messages
2025/09/20 03:46:58 [WebSocket] Client 20250920-034511-127.0.0.1:11398 sent 500 messages
2025/09/20 03:46:58 [WebSocket] Client 20250920-034511-127.0.0.1:11398 sent 600 messages
fatal error: concurrent map iteration and map write

goroutine 36 [running]:
reflect.mapiterinit(0x454be9?, 0x50?, 0xce50c0?)
        /usr/local/go/src/runtime/map.go:1392 +0x13
reflect.(*MapIter).Next(0xc9bec0?)
        /usr/local/go/src/reflect/value.go:2000 +0x57
encoding/json.mapEncoder.encode({0xffffffffffffffff?}, 0xc0001b7dc0, {0xc9bec0?, 0xc0003523e0?, 0x2?}, {0xa?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:745 +0x334
encoding/json.structEncoder.encode({{{0xc000370008, 0x18, 0x23}, 0xc0002fe7b0, 0xc0002fe7e0}}, 0xc0001b7dc0, {0xd89d80?, 0xc0003523c0?, 0xc0001b7db0?}, {0x0, ...})
        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.ptrEncoder.encode({0xc0001b7db0?}, 0xc0001b7dc0, {0xc407e0?, 0xc0001b7db0?, 0xc0001b7db0?}, {0x8?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:876 +0x23c
encoding/json.structEncoder.encode({{{0xc0000da008, 0x4, 0x4}, 0xc0002fe870, 0xc0002fe8a0}}, 0xc0001b7dc0, {0xd25900?, 0xc0001b7d80?, 0x411b1b?}, {0x0, ...})
        /usr/local/go/src/encoding/json/encode.go:704 +0x21e
encoding/json.(*encodeState).reflectValue(0xc0001b7dc0, {0xd25900?, 0xc0001b7d80?, 0x411ec5?}, {0x38?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:321 +0x73
encoding/json.(*encodeState).marshal(0x411b1b?, {0xd25900?, 0xc0001b7d80?}, {0x71?, 0x0?})
        /usr/local/go/src/encoding/json/encode.go:297 +0xc5
encoding/json.Marshal({0xd25900, 0xc0001b7d80})
        /usr/local/go/src/encoding/json/encode.go:163 +0xd0
main.(*WebSocketClient).sendMessage(0xc0002c01c0, {{0xda70f9, 0x6}, {0xd9a220, 0xc0000fd188}, {0x0, 0x0}, 0xc0003523c0})
        /app/websocket.go:290 +0x10c
main.(*WebSocketClient).sendNewLogWithStats(_, {{0xc0004ad998, 0x18}, {0xc0003e3e80, 0x19}, {0xc00042a9d0, 0xc}, {0xc00042abb8, 0x3}, {0xc0004518b0, ...}, ...})
        /app/websocket.go:359 +0x32a
main.(*WebSocketClient).WritePump(0xc0002c01c0)
        /app/websocket.go:193 +0x745
main.(*WebSocketClient).Start.func1()
        /app/websocket.go:57 +0x49
created by main.(*WebSocketClient).Start in goroutine 49
        /app/websocket.go:49 +0x56

goroutine 1 [chan receive, 1 minutes]:
main.main()
        /app/main.go:169 +0x1398

goroutine 6 [select, 1 minutes]:
github.com/patrickmn/go-cache.(*janitor).Run(0xc0003468f0, 0xc0003d0580)
        /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1079 +0x7d
created by github.com/patrickmn/go-cache.runJanitor in goroutine 1
        /go/pkg/mod/github.com/patrickmn/go-cache@v2.1.0+incompatible/cache.go:1099 +0xdb

goroutine 7 [select, 1 minutes]:
main.startRetryProcessor.func1()
        /app/geoLocation.go:585 +0x5a
created by main.startRetryProcessor in goroutine 1
        /app/geoLocation.go:583 +0x4c

goroutine 8 [IO wait, 1 minutes]:
internal/poll.runtime_pollWait(0x7334a4384e50, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x3?, 0x426f65?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc000218a00)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc000218a00)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc0000ceb80)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc0000ceb80)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
google.golang.org/grpc.(*Server).Serve(0xc00007c600, {0xeefff8, 0xc0000ceb80})
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/server.go:871 +0x469
main.(*OTLPReceiver).startGRPCServer.func1()
        /app/otlp.go:154 +0x26
created by main.(*OTLPReceiver).startGRPCServer in goroutine 1
        /app/otlp.go:153 +0x148

goroutine 9 [IO wait, 1 minutes]:
internal/poll.runtime_pollWait(0x7334a4384d58, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0x7?, 0x10?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc000218a80)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc000218a80)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc0000cec40)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc0000cec40)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
net/http.(*Server).Serve(0xc000002690, {0xeefff8, 0xc0000cec40})
        /usr/local/go/src/net/http/server.go:3260 +0x33e
net/http.(*Server).ListenAndServe(0xc000002690)
        /usr/local/go/src/net/http/server.go:3189 +0x71
main.(*OTLPReceiver).startHTTPServer.func1()
        /app/otlp.go:177 +0x1f
created by main.(*OTLPReceiver).startHTTPServer in goroutine 1
        /app/otlp.go:176 +0x28d

goroutine 11 [syscall, 1 minutes]:
os/signal.signal_recv()
        /usr/local/go/src/runtime/sigqueue.go:152 +0x29
os/signal.loop()
        /usr/local/go/src/os/signal/signal_unix.go:23 +0x13
created by os/signal.Notify.func1.1 in goroutine 1
        /usr/local/go/src/os/signal/signal.go:151 +0x1f

goroutine 19 [chan receive, 1 minutes]:
main.main.func1()
        /app/main.go:67 +0x26
created by main.main in goroutine 1
        /app/main.go:66 +0x513

goroutine 20 [select, 1 minutes]:
main.startWebSocketHealthMonitor.func1()
        /app/main.go:275 +0x71
created by main.startWebSocketHealthMonitor in goroutine 1
        /app/main.go:273 +0x7d

goroutine 22 [IO wait, 1 minutes]:
internal/poll.runtime_pollWait(0x7334a4384b68, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0xa?, 0x7334a4258df8?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Accept(0xc00041c000)
        /usr/local/go/src/internal/poll/fd_unix.go:611 +0x2ac
net.(*netFD).accept(0xc00041c000)
        /usr/local/go/src/net/fd_unix.go:172 +0x29
net.(*TCPListener).accept(0xc00041e000)
        /usr/local/go/src/net/tcpsock_posix.go:159 +0x1e
net.(*TCPListener).Accept(0xc00041e000)
        /usr/local/go/src/net/tcpsock.go:327 +0x30
net/http.(*Server).Serve(0xc0000e20f0, {0xeefff8, 0xc00041e000})
        /usr/local/go/src/net/http/server.go:3260 +0x33e
net/http.(*Server).ListenAndServe(0xc0000e20f0)
        /usr/local/go/src/net/http/server.go:3189 +0x71
main.main.func2()
        /app/main.go:163 +0x1b
created by main.main in goroutine 1
        /app/main.go:162 +0x137b

goroutine 12 [select]:
github.com/fsnotify/fsnotify.(*Watcher).sendEvent(...)
        /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:276
github.com/fsnotify/fsnotify.(*Watcher).readEvents(0xc0003d0780)
        /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:564 +0x7ca
created by github.com/fsnotify/fsnotify.NewBufferedWatcher in goroutine 21
        /go/pkg/mod/github.com/fsnotify/fsnotify@v1.7.0/backend_inotify.go:270 +0x1c5

goroutine 51 [select]:
google.golang.org/grpc/internal/transport.(*controlBuffer).get(0xc0002f2140, 0x1)
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/controlbuf.go:418 +0x113
google.golang.org/grpc/internal/transport.(*loopyWriter).run(0xc0002a6000)
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/controlbuf.go:552 +0x86
google.golang.org/grpc/internal/transport.NewServerTransport.func2()
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/http2_server.go:325 +0xd2
created by google.golang.org/grpc/internal/transport.NewServerTransport in goroutine 50
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/http2_server.go:322 +0x185e

goroutine 52 [select, 1 minutes]:
google.golang.org/grpc/internal/transport.(*http2Server).keepalive(0xc0001c01a0)
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/http2_server.go:1133 +0x205
created by google.golang.org/grpc/internal/transport.NewServerTransport in goroutine 50
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/http2_server.go:328 +0x18a5

goroutine 53 [IO wait]:
internal/poll.runtime_pollWait(0x7334a4384978, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0xc00041c100?, 0xc00038c000?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Read(0xc00041c100, {0xc00038c000, 0x8000, 0x8000})
        /usr/local/go/src/internal/poll/fd_unix.go:164 +0x27a
net.(*netFD).Read(0xc00041c100, {0xc00038c000?, 0xc000459bd8?, 0x41a205?})
        /usr/local/go/src/net/fd_posix.go:55 +0x25
net.(*conn).Read(0xc0003de000, {0xc00038c000?, 0x409bfe?, 0x46f6d2?})
        /usr/local/go/src/net/net.go:185 +0x45
bufio.(*Reader).Read(0xc00025bc80, {0xc0003f4120, 0x9, 0xc00025bf20?})
        /usr/local/go/src/bufio/bufio.go:241 +0x197
io.ReadAtLeast({0xee9ac0, 0xc00025bc80}, {0xc0003f4120, 0x9, 0x9}, 0x9)
        /usr/local/go/src/io/io.go:335 +0x90
io.ReadFull(...)
        /usr/local/go/src/io/io.go:354
golang.org/x/net/http2.readFrameHeader({0xc0003f4120, 0x9, 0xa99313?}, {0xee9ac0?, 0xc00025bc80?})
        /go/pkg/mod/golang.org/x/net@v0.22.0/http2/frame.go:237 +0x65
golang.org/x/net/http2.(*Framer).ReadFrame(0xc0003f40e0)
        /go/pkg/mod/golang.org/x/net@v0.22.0/http2/frame.go:498 +0x85
google.golang.org/grpc/internal/transport.(*http2Server).HandleStreams(0xc0001c01a0, {0xef2c18, 0xc0000bb7a0}, 0xc0000bb7d0)
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/internal/transport/http2_server.go:617 +0x157
google.golang.org/grpc.(*Server).serveStreams(0xc00007c600, {0xef29c0?, 0x155f0c0?}, {0xef73c0, 0xc0001c01a0}, {0xef6d58?, 0xc0003de000?})
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/server.go:1012 +0x3b6
google.golang.org/grpc.(*Server).handleRawConn.func1()
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/server.go:939 +0x56
created by google.golang.org/grpc.(*Server).handleRawConn in goroutine 50
        /go/pkg/mod/google.golang.org/grpc@v1.60.1/server.go:938 +0x17a

goroutine 37 [IO wait, 1 minutes]:
internal/poll.runtime_pollWait(0x7334a4384a70, 0x72)
        /usr/local/go/src/runtime/netpoll.go:345 +0x85
internal/poll.(*pollDesc).wait(0xc00041c080?, 0xc00045f000?, 0x0)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:84 +0x27
internal/poll.(*pollDesc).waitRead(...)
        /usr/local/go/src/internal/poll/fd_poll_runtime.go:89
internal/poll.(*FD).Read(0xc00041c080, {0xc00045f000, 0x400, 0x400})
        /usr/local/go/src/internal/poll/fd_unix.go:164 +0x27a
net.(*netFD).Read(0xc00041c080, {0xc00045f000?, 0x0?, 0x0?})
        /usr/local/go/src/net/fd_posix.go:55 +0x25
net.(*conn).Read(0xc000060000, {0xc00045f000?, 0xc000415c50?, 0x56cde8?})
        /usr/local/go/src/net/net.go:185 +0x45
bufio.(*Reader).fill(0xc000120300)
        /usr/local/go/src/bufio/bufio.go:110 +0x103
bufio.(*Reader).Peek(0xc000120300, 0x2)
        /usr/local/go/src/bufio/bufio.go:148 +0x53
github.com/gorilla/websocket.(*Conn).read(0xc0001dc160, 0x43e2a8?)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:378 +0x26
github.com/gorilla/websocket.(*Conn).advanceFrame(0xc0001dc160)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:824 +0x6d
github.com/gorilla/websocket.(*Conn).NextReader(0xc0001dc160)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:1034 +0x13e
github.com/gorilla/websocket.(*Conn).ReadMessage(0xc22ba6c0f1d5ea79?)
        /go/pkg/mod/github.com/gorilla/websocket@v1.5.1/conn.go:1120 +0x13
main.(*WebSocketClient).ReadPump(0xc0002c01c0)
        /app/websocket.go:108 +0x167
main.(*WebSocketClient).Start.func2()
        /app/websocket.go:68 +0x49
created by main.(*WebSocketClient).Start in goroutine 49
        /app/websocket.go:60 +0x96

goroutine 13 [runnable]:
main.(*LogParser).processLogEntry(0xc0000fcc88, 0xc000505788, 0x1)
        /app/logParser.go:657 +0x23a
main.(*LogParser).parseLine(0xc0000fcc88, {0xc00045e400, 0x3ff}, 0x1)
        /app/logParser.go:598 +0x14f6
main.(*FileWatcher).readNewLines(0xc0002c1570)
        /app/fileWatcher.go:190 +0x1ef
main.(*FileWatcher).checkFile(0xc0002c1570)
        /app/fileWatcher.go:246 +0xde
main.(*FileWatcher).watchLoop(0xc0002c1570)
        /app/fileWatcher.go:274 +0x6b8
created by main.(*FileWatcher).Start in goroutine 21
        /app/fileWatcher.go:71 +0x1c9

goroutine 14 [select]:
main.(*FileWatcher).pollLoop(0xc0002c1570)
        /app/fileWatcher.go:324 +0xcf
created by main.(*FileWatcher).Start in goroutine 21
        /app/fileWatcher.go:72 +0x20b

goroutine 15 [sleep]:
time.Sleep(0x12a05f200)
        /usr/local/go/src/runtime/time.go:195 +0x115
main.(*LogParser).startGeoProcessing(0xc0000fcc88)
        /app/logParser.go:1124 +0x214
created by main.(*LogParser).SetLogFiles in goroutine 21
        /app/logParser.go:318 +0xc5b

[milindpatel63]

I don't know anything about Go programming language, but i asked cursor to fix this issue, and it modified the logParser.go file and it seems to have fixed it for me.
I have tested upto 0.5 samplerate in traefik.
Here's the modified file for anyone interested. (Or you could just ask any AI yourself and it will probably fix it)

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"math"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
)

type LogEntry struct {
	ID                      string  `json:"id"`
	Timestamp               string  `json:"timestamp"`
	ClientIP                string  `json:"clientIP"`
	Method                  string  `json:"method"`
	Path                    string  `json:"path"`
	Status                  int     `json:"status"`
	ResponseTime            float64 `json:"responseTime"`
	ServiceName             string  `json:"serviceName"`
	RouterName              string  `json:"routerName"`
	Host                    string  `json:"host"`
	RequestAddr             string  `json:"requestAddr"`
	RequestHost             string  `json:"requestHost"`
	UserAgent               string  `json:"userAgent"`
	Size                    int     `json:"size"`
	Country                 *string `json:"country"`
	City                    *string `json:"city"`
	CountryCode             *string `json:"countryCode"`
	Lat                     *float64 `json:"lat"`
	Lon                     *float64 `json:"lon"`
	
	// Additional fields from the original
	StartUTC                string  `json:"StartUTC,omitempty"`
	StartLocal              string  `json:"StartLocal,omitempty"`
	Duration                int64   `json:"Duration,omitempty"`
	ServiceURL              string  `json:"ServiceURL,omitempty"`
	ServiceAddr             string  `json:"ServiceAddr,omitempty"`
	ClientHost              string  `json:"ClientHost,omitempty"`
	ClientPort              string  `json:"ClientPort,omitempty"`
	ClientUsername          string  `json:"ClientUsername,omitempty"`
	RequestPort             string  `json:"RequestPort,omitempty"`
	RequestProtocol         string  `json:"RequestProtocol,omitempty"`
	RequestScheme           string  `json:"RequestScheme,omitempty"`
	RequestLine             string  `json:"RequestLine,omitempty"`
	RequestContentSize      int     `json:"RequestContentSize,omitempty"`
	OriginDuration          int64   `json:"OriginDuration,omitempty"`
	OriginContentSize       int     `json:"OriginContentSize,omitempty"`
	OriginStatus            int     `json:"OriginStatus,omitempty"`
	DownstreamStatus        int     `json:"DownstreamStatus,omitempty"`
	RequestCount            int     `json:"RequestCount,omitempty"`
	GzipRatio               float64 `json:"GzipRatio,omitempty"`
	Overhead                int64   `json:"Overhead,omitempty"`
	RetryAttempts           int     `json:"RetryAttempts,omitempty"`
	TLSVersion              string  `json:"TLSVersion,omitempty"`
	TLSCipher               string  `json:"TLSCipher,omitempty"`
	TLSClientSubject        string  `json:"TLSClientSubject,omitempty"`
	TraceId                 string  `json:"TraceId,omitempty"`
	SpanId                  string  `json:"SpanId,omitempty"`
	
	// OTLP-specific metadata
	DataSource              string  `json:"dataSource,omitempty"` // "logfile", "otlp"
	OTLPReceiveTime         string  `json:"otlpReceiveTime,omitempty"`
}

type RawLogEntry map[string]interface{}

type Stats struct {
	TotalRequests          int                    `json:"totalRequests"`
	StatusCodes            map[int]int            `json:"statusCodes"`
	Services               map[string]int         `json:"services"`
	Routers                map[string]int         `json:"routers"`
	Methods                map[string]int         `json:"methods"`
	AvgResponseTime        float64                `json:"avgResponseTime"`
	Requests5xx            int                    `json:"requests5xx"`
	Requests4xx            int                    `json:"requests4xx"`
	Requests2xx            int                    `json:"requests2xx"`
	RequestsPerSecond      int                    `json:"requestsPerSecond"`
	TopIPs                 []IPCount              `json:"topIPs"`
	Countries              map[string]int         `json:"countries"`
	TopCountries           []CountryCount         `json:"topCountries"`
	TopRouters             []RouterCount          `json:"topRouters"`
	TopRequestAddrs        []AddrCount            `json:"topRequestAddrs"`
	TopRequestHosts        []HostCount            `json:"topRequestHosts"`
	GeoProcessingRemaining int                    `json:"geoProcessingRemaining"`
	TotalDataTransmitted   int64                  `json:"totalDataTransmitted"`
	OldestLogTime          string                 `json:"oldestLogTime"`
	NewestLogTime          string                 `json:"newestLogTime"`
	AnalysisPeriod         string                 `json:"analysisPeriod"`
	
	// OTLP-specific stats
	OTLPRequests           int                    `json:"otlpRequests"`
	LogFileRequests        int                    `json:"logFileRequests"`
	DataSources            map[string]int         `json:"dataSources"`
}

type IPCount struct {
	IP    string `json:"ip"`
	Count int    `json:"count"`
}

type CountryCount struct {
	Country     string `json:"country"`
	CountryCode string `json:"countryCode"`
	Count       int    `json:"count"`
}

type RouterCount struct {
	Router string `json:"router"`
	Count  int    `json:"count"`
}

type AddrCount struct {
	Addr  string `json:"addr"`
	Count int    `json:"count"`
}

type HostCount struct {
	Host  string `json:"host"`
	Count int    `json:"count"`
}

type LogsParams struct {
	Page    int     `json:"page"`
	Limit   int     `json:"limit"`
	Filters Filters `json:"filters"`
}

type Filters struct {
	Service        string `json:"service"`
	Status         string `json:"status"`
	Router         string `json:"router"`
	HideUnknown    bool   `json:"hideUnknown"`
	HidePrivateIPs bool   `json:"hidePrivateIPs"`
	DataSource     string `json:"dataSource"` // "logfile", "otlp", "all"
}

type LogsResult struct {
	Logs       []LogEntry `json:"logs"`
	Total      int        `json:"total"`
	Page       int        `json:"page"`
	TotalPages int        `json:"totalPages"`
}

type GeoStats struct {
	Countries              []CountryCount `json:"countries"`
	TotalCountries         int            `json:"totalCountries"`
	GeoProcessingRemaining int            `json:"geoProcessingRemaining"`
}

type LogParser struct {
	logs                  []LogEntry
	maxLogs               int
	fileWatchers          []*FileWatcher  // Changed: support multiple watchers
	stats                 Stats
	lastTimestamp         time.Time
	requestsInLastSecond  int
	geoProcessingQueue    []string
	processedIPs          map[string]bool
	isProcessingGeo       bool
	mu                    sync.RWMutex
	listeners             []chan LogEntry
	topIPs                map[string]int
	topRouters            map[string]int
	topRequestAddrs       map[string]int
	topRequestHosts       map[string]int
	totalDataTransmitted  int64
	oldestLogTime         time.Time
	newestLogTime         time.Time
	stopChan              chan struct{}
	geoStopChan           chan struct{}
	
	// OTLP-specific fields
	otlpRequestCount      int
	logFileRequestCount   int
	dataSourceCounts      map[string]int
}

func NewLogParser() *LogParser {
	return &LogParser{
		logs:            make([]LogEntry, 0),
		maxLogs:         10000,
		fileWatchers:    make([]*FileWatcher, 0), // Initialize as slice
		stats:           Stats{
			StatusCodes:     make(map[int]int),
			Services:        make(map[string]int),
			Routers:         make(map[string]int),
			Methods:         make(map[string]int),
			Countries:       make(map[string]int),
			DataSources:     make(map[string]int),
		},
		lastTimestamp:        time.Now(),
		geoProcessingQueue:   make([]string, 0),
		processedIPs:         make(map[string]bool),
		listeners:            make([]chan LogEntry, 0),
		topIPs:               make(map[string]int),
		topRouters:           make(map[string]int),
		topRequestAddrs:      make(map[string]int),
		topRequestHosts:      make(map[string]int),
		totalDataTransmitted: 0,
		oldestLogTime:        time.Time{},
		newestLogTime:        time.Time{},
		stopChan:             make(chan struct{}),
		geoStopChan:          make(chan struct{}),
		dataSourceCounts:     make(map[string]int),
	}
}

func (lp *LogParser) Stop() {
	close(lp.stopChan)
	close(lp.geoStopChan)
	
	// Stop all file watchers
	for _, fw := range lp.fileWatchers {
		if fw != nil {
			fw.Stop()
		}
	}
	lp.fileWatchers = nil
	
	// Clean up listeners
	lp.mu.Lock()
	for _, ch := range lp.listeners {
		close(ch)
	}
	lp.listeners = nil
	lp.mu.Unlock()
}

// Enhanced function to handle multiple paths and directories
func (lp *LogParser) SetLogFiles(logPaths []string) error {
	// Stop existing file watchers
	for _, fw := range lp.fileWatchers {
		if fw != nil {
			fw.Stop()
		}
	}
	lp.fileWatchers = nil

	log.Printf("Setting up monitoring for %d log path(s)", len(logPaths))

	var filesToMonitor []string

	// Process each path
	for _, path := range logPaths {
		path = strings.TrimSpace(path)
		if path == "" {
			continue
		}

		// Remove trailing slash for consistency
		if strings.HasSuffix(path, "/") && len(path) > 1 {
			path = path[:len(path)-1]
		}

		// Check if path exists
		info, err := os.Stat(path)
		if err != nil {
			log.Printf("Warning: Path %s does not exist: %v", path, err)
			continue
		}

		if info.IsDir() {
			// It's a directory - find log files
			foundFiles, err := lp.findLogFilesInDirectory(path)
			if err != nil {
				log.Printf("Error scanning directory %s: %v", path, err)
				continue
			}
			filesToMonitor = append(filesToMonitor, foundFiles...)
		} else {
			// It's a file
			filesToMonitor = append(filesToMonitor, path)
		}
	}

	if len(filesToMonitor) == 0 {
		return fmt.Errorf("no valid log files found in provided paths: %v", logPaths)
	}

	log.Printf("Found %d log files to monitor: %v", len(filesToMonitor), filesToMonitor)

	// Create file watchers for each file
	for _, filePath := range filesToMonitor {
		fw, err := NewFileWatcher(filePath, lp)
		if err != nil {
			log.Printf("Failed to create file watcher for %s: %v", filePath, err)
			continue
		}

		lp.fileWatchers = append(lp.fileWatchers, fw)

		// Load recent logs from this file (reduced per file to avoid memory issues)
		lp.loadRecentLogs(filePath, 500)

		// Start file watching
		if err := fw.Start(); err != nil {
			log.Printf("Failed to start file watcher for %s: %v", filePath, err)
			continue
		}

		log.Printf("Setting up tail for file: %s", filePath)
	}

	if len(lp.fileWatchers) == 0 {
		return fmt.Errorf("failed to start any file watchers for paths: %v", logPaths)
	}

	log.Printf("Successfully started %d file watchers", len(lp.fileWatchers))

	// Start geo processing
	go lp.startGeoProcessing()

	return nil
}

// Find log files in a directory
func (lp *LogParser) findLogFilesInDirectory(dirPath string) ([]string, error) {
	var logFiles []string

	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			log.Printf("Warning: Error accessing %s: %v", path, err)
			return nil // Continue walking
		}

		// Skip directories
		if info.IsDir() {
			return nil
		}

		// Skip very small files (likely empty)
		if info.Size() < 50 {
			return nil
		}

		// Check if it's likely a log file
		if lp.isLogFile(path, info) {
			logFiles = append(logFiles, path)
			log.Printf("Found log file: %s (size: %d bytes, modified: %s)", 
				path, info.Size(), info.ModTime().Format(time.RFC3339))
		}

		return nil
	})

	if err != nil {
		return nil, err
	}

	// Sort files by modification time (newest first)
	sort.Slice(logFiles, func(i, j int) bool {
		infoI, errI := os.Stat(logFiles[i])
		infoJ, errJ := os.Stat(logFiles[j])
		if errI != nil || errJ != nil {
			return false
		}
		return infoI.ModTime().After(infoJ.ModTime())
	})

	log.Printf("Found %d log files in directory %s", len(logFiles), dirPath)
	return logFiles, nil
}

// Determine if a file is likely a log file
func (lp *LogParser) isLogFile(path string, info os.FileInfo) bool {
	name := strings.ToLower(info.Name())
	
	// Common log file patterns
	logPatterns := []string{
		".log",
		"access",
		"error", 
		"traefik",
		"nginx",
		"apache",
	}

	// Skip very old files (older than 7 days) unless they're large
	if time.Since(info.ModTime()) > 7*24*time.Hour && info.Size() < 1024*1024 {
		return false
	}

	// Check for log patterns in filename
	for _, pattern := range logPatterns {
		if strings.Contains(name, pattern) {
			// Additional check: if it contains "access", verify it's likely a JSON log
			if strings.Contains(name, "access") {
				return lp.hasJSONContent(path)
			}
			return true
		}
	}

	// Check for JSON content in file (for files without obvious log extensions)
	return lp.hasJSONContent(path)
}

// Check if file contains JSON log entries
func (lp *LogParser) hasJSONContent(filePath string) bool {
	file, err := os.Open(filePath)
	if err != nil {
		return false
	}
	defer file.Close()

	// Read first few lines
	buf := make([]byte, 2048)
	n, err := file.Read(buf)
	if err != nil && err != io.EOF {
		return false
	}

	content := string(buf[:n])
	lines := strings.Split(content, "\n")

	jsonLinesFound := 0
	linesChecked := 0

	// Check first several lines
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if len(line) == 0 {
			continue
		}
		
		linesChecked++
		if linesChecked > 10 { // Don't check too many lines
			break
		}

		// Check if line looks like JSON
		if strings.HasPrefix(line, "{") && strings.HasSuffix(line, "}") {
			// Try to parse as JSON
			var test map[string]interface{}
			if json.Unmarshal([]byte(line), &test) == nil {
				jsonLinesFound++
				
				// Check if it looks like a Traefik log entry
				if _, hasTime := test["time"]; hasTime {
					if _, hasLevel := test["level"]; hasLevel {
						return true // Definitely looks like a Traefik log
					}
					if _, hasStatus := test["DownstreamStatus"]; hasStatus {
						return true // Looks like a Traefik access log
					}
				}
			}
		}
	}

	// If more than half the checked lines are JSON, consider it a log file
	return linesChecked > 0 && float64(jsonLinesFound)/float64(linesChecked) > 0.5
}

// Helper function for min
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func (lp *LogParser) loadRecentLogs(filePath string, maxLines int) {
	file, err := os.Open(filePath)
	if err != nil {
		log.Printf("Error opening file %s: %v", filePath, err)
		return
	}
	defer file.Close()

	// Get file size
	stat, err := file.Stat()
	if err != nil {
		return
	}

	// Start from end and read backwards to get last N lines
	var lines []string
	var offset int64 = stat.Size()
	bufferSize := int64(8192)
	
	for len(lines) < maxLines && offset > 0 {
		if offset < bufferSize {
			bufferSize = offset
		}
		offset -= bufferSize
		
		buffer := make([]byte, bufferSize)
		_, err := file.ReadAt(buffer, offset)
		if err != nil && err != io.EOF {
			break
		}
		
		// Process buffer in reverse
		content := string(buffer)
		newLines := strings.Split(content, "\n")
		
		// Prepend to lines slice
		if len(lines) > 0 && len(newLines) > 0 {
			// Handle partial line at boundary
			lines[0] = newLines[len(newLines)-1] + lines[0]
			if len(newLines) > 1 {
				lines = append(newLines[:len(newLines)-1], lines...)
			}
		} else {
			lines = append(newLines, lines...)
		}
		
		if len(lines) > maxLines {
			lines = lines[len(lines)-maxLines:]
			break
		}
	}

	// Parse the lines
	validLines := 0
	for _, line := range lines {
		if strings.TrimSpace(line) != "" {
			if lp.parseLine(line, false) {
				validLines++
			}
		}
	}
	
	log.Printf("Loading %d valid log entries from %s (out of %d lines)", validLines, filePath, len(lines))
}

func (lp *LogParser) parseLine(line string, emit bool) bool {
	if strings.TrimSpace(line) == "" {
		return false
	}

	var raw RawLogEntry
	if err := json.Unmarshal([]byte(line), &raw); err != nil {
		return false // Ignore non-JSON lines
	}

	// Check if this looks like a valid Traefik log entry
	if !lp.isValidTraefikLog(raw) {
		return false
	}

	logEntry := LogEntry{
		ID:           fmt.Sprintf("%d-%d", time.Now().UnixNano(), len(lp.logs)),
		Timestamp:    getStringValue(raw, "time", time.Now().Format(time.RFC3339)),
		ClientIP:     lp.extractIP(getStringValue(raw, "ClientHost", "")),
		Method:       getStringValue(raw, "RequestMethod", "GET"),
		Path:         getStringValue(raw, "RequestPath", ""),
		Status:       getIntValue(raw, "DownstreamStatus", 0),
		ResponseTime: getFloatValue(raw, "Duration", 0) / 1e6, // Convert nanoseconds to ms
		ServiceName:  getStringValue(raw, "ServiceName", "unknown"),
		RouterName:   getStringValue(raw, "RouterName", "unknown"),
		Host:         getStringValue(raw, "RequestHost", ""),
		RequestAddr:  getStringValue(raw, "RequestAddr", ""),
		RequestHost:  getStringValue(raw, "RequestHost", ""),
		UserAgent:    getStringValue(raw, "request_User-Agent", ""),
		Size:         getIntValue(raw, "DownstreamContentSize", 0),
		
		// Additional fields
		StartUTC:           getStringValue(raw, "StartUTC", ""),
		StartLocal:         getStringValue(raw, "StartLocal", ""),
		Duration:           getInt64Value(raw, "Duration", 0),
		ServiceURL:         getStringValue(raw, "ServiceURL", ""),
		ServiceAddr:        getStringValue(raw, "ServiceAddr", ""),
		ClientHost:         getStringValue(raw, "ClientHost", ""),
		ClientPort:         getStringValue(raw, "ClientPort", ""),
		ClientUsername:     getStringValue(raw, "ClientUsername", ""),
		RequestPort:        getStringValue(raw, "RequestPort", ""),
		RequestProtocol:    getStringValue(raw, "RequestProtocol", ""),
		RequestScheme:      getStringValue(raw, "RequestScheme", ""),
		RequestLine:        getStringValue(raw, "RequestLine", ""),
		RequestContentSize: getIntValue(raw, "RequestContentSize", 0),
		OriginDuration:     getInt64Value(raw, "OriginDuration", 0),
		OriginContentSize:  getIntValue(raw, "OriginContentSize", 0),
		OriginStatus:       getIntValue(raw, "OriginStatus", 0),
		DownstreamStatus:   getIntValue(raw, "DownstreamStatus", 0),
		RequestCount:       getIntValue(raw, "RequestCount", 0),
		GzipRatio:          getFloatValue(raw, "GzipRatio", 0),
		Overhead:           getInt64Value(raw, "Overhead", 0),
		RetryAttempts:      getIntValue(raw, "RetryAttempts", 0),
		TLSVersion:         getStringValue(raw, "TLSVersion", ""),
		TLSCipher:          getStringValue(raw, "TLSCipher", ""),
		TLSClientSubject:   getStringValue(raw, "TLSClientSubject", ""),
		TraceId:            getStringValue(raw, "TraceId", ""),
		SpanId:             getStringValue(raw, "SpanId", ""),
		
		// Mark as log file source
		DataSource:         "logfile",
	}

	return lp.processLogEntry(&logEntry, emit)
}

// Check if a raw log entry looks like a valid Traefik log
func (lp *LogParser) isValidTraefikLog(raw RawLogEntry) bool {
	// Must have a timestamp
	if _, hasTime := raw["time"]; !hasTime {
		return false
	}

	// For access logs, must have downstream status or request method
	if _, hasStatus := raw["DownstreamStatus"]; hasStatus {
		return true
	}
	
	if _, hasMethod := raw["RequestMethod"]; hasMethod {
		return true
	}

	// For other logs, check for level (but we might not want these)
	if level, hasLevel := raw["level"]; hasLevel {
		// Only accept error/warn logs, ignore debug/info
		if levelStr, ok := level.(string); ok {
			return levelStr == "error" || levelStr == "warn"
		}
	}

	return false
}

// OTLP Log Entry Processing - Main entry point for OTLP data
func (lp *LogParser) ProcessOTLPLogEntry(logEntry LogEntry) {
	// Set OTLP-specific metadata
	logEntry.DataSource = "otlp"
	logEntry.OTLPReceiveTime = time.Now().Format(time.RFC3339)
	
	// Process the same way as file-based log entries
	lp.processLogEntry(&logEntry, true) // Always emit OTLP entries for real-time updates
	
	log.Printf("[LogParser] Processed OTLP log entry - Trace: %s, Span: %s", logEntry.TraceId, logEntry.SpanId)
}

// Common log entry processing logic used by both file and OTLP entries
func (lp *LogParser) processLogEntry(logEntry *LogEntry, emit bool) bool {
	// Try to get geolocation from cache immediately
	if logEntry.ClientIP != "unknown" && !lp.isPrivateIP(logEntry.ClientIP) {
		if geoData := GetGeoLocationFromCache(logEntry.ClientIP); geoData != nil {
			logEntry.Country = &geoData.Country
			logEntry.City = &geoData.City
			logEntry.CountryCode = &geoData.CountryCode
			logEntry.Lat = &geoData.Lat
			logEntry.Lon = &geoData.Lon
		}
	}

	lp.updateStats(logEntry)

	lp.mu.Lock()
	// Add log to the main logs slice
	lp.logs = append([]LogEntry{*logEntry}, lp.logs...)
	if len(lp.logs) > lp.maxLogs {
		lp.logs = lp.logs[:lp.maxLogs]
	}

	// Add to geo processing queue if needed and not in cache
	if logEntry.ClientIP != "unknown" && !lp.isPrivateIP(logEntry.ClientIP) && logEntry.Country == nil {
		if !lp.processedIPs[logEntry.ClientIP] {
			lp.geoProcessingQueue = append(lp.geoProcessingQueue, logEntry.ClientIP)
			lp.processedIPs[logEntry.ClientIP] = true
		}
	}
	
	// Update data source counters
	lp.dataSourceCounts[logEntry.DataSource]++
	if logEntry.DataSource == "otlp" {
		lp.otlpRequestCount++
	} else if logEntry.DataSource == "logfile" {
		lp.logFileRequestCount++
	}
	
	lp.mu.Unlock()

	if emit {
		lp.notifyListeners(*logEntry)
	}

	return true
}

func (lp *LogParser) ClearLogs() {
	lp.mu.Lock()
	defer lp.mu.Unlock()

	log.Println("Clearing all logs and stats")
	
	// Clear logs
	lp.logs = make([]LogEntry, 0)
	
	// Reset stats
	lp.stats = Stats{
		StatusCodes:     make(map[int]int),
		Services:        make(map[string]int),
		Routers:         make(map[string]int),
		Methods:         make(map[string]int),
		Countries:       make(map[string]int),
		DataSources:     make(map[string]int),
	}
	
	// Reset counters
	lp.topIPs = make(map[string]int)
	lp.topRouters = make(map[string]int)
	lp.topRequestAddrs = make(map[string]int)
	lp.topRequestHosts = make(map[string]int)
	lp.requestsInLastSecond = 0
	
	// Reset data tracking
	lp.totalDataTransmitted = 0
	lp.oldestLogTime = time.Time{}
	lp.newestLogTime = time.Time{}
	
	// Reset OTLP counters
	lp.otlpRequestCount = 0
	lp.logFileRequestCount = 0
	lp.dataSourceCounts = make(map[string]int)
	
	// Clear geo processing data
	lp.geoProcessingQueue = make([]string, 0)
	lp.processedIPs = make(map[string]bool)
	
	// Notify listeners of the clear
	for _, listener := range lp.listeners {
		select {
		case listener <- LogEntry{ID: "CLEAR"}:
		default:
		}
	}
}

func (lp *LogParser) extractIP(clientAddr string) string {
	if clientAddr == "" {
		return "unknown"
	}

	// Handle IPv6 addresses in brackets
	if strings.HasPrefix(clientAddr, "[") {
		if match := strings.Index(clientAddr, "]"); match != -1 {
			return clientAddr[1:match]
		}
	}

	// Handle IPv4 with port
	if strings.Contains(clientAddr, ".") && strings.Contains(clientAddr, ":") {
		if lastColon := strings.LastIndex(clientAddr, ":"); lastColon != -1 {
			return clientAddr[:lastColon]
		}
	}

	// Handle IPv6 without brackets
	if strings.Contains(clientAddr, ":") && !strings.Contains(clientAddr, ".") {
		return clientAddr
	}

	return clientAddr
}

func (lp *LogParser) isPrivateIP(ip string) bool {
	if ip == "" || ip == "unknown" {
		return true
	}

	parts := strings.Split(ip, ".")
	if len(parts) != 4 {
		return false
	}

	return ip == "127.0.0.1" ||
		ip == "localhost" ||
		strings.HasPrefix(ip, "::") ||
		ip == "::1" ||
		parts[0] == "10" ||
		(parts[0] == "172" && isInRange(parts[1], 16, 31)) ||
		(parts[0] == "192" && parts[1] == "168") ||
		(parts[0] == "169" && parts[1] == "254")
}

func isInRange(s string, min, max int) bool {
	n, err := strconv.Atoi(s)
	if err != nil {
		return false
	}
	return n >= min && n <= max
}

func (lp *LogParser) updateStats(log *LogEntry) {
	lp.mu.Lock()
	defer lp.mu.Unlock()

	lp.stats.TotalRequests++

	statusGroup := log.Status / 100
	lp.stats.StatusCodes[log.Status]++

	switch statusGroup {
	case 2:
		lp.stats.Requests2xx++
	case 4:
		lp.stats.Requests4xx++
	case 5:
		lp.stats.Requests5xx++
	}

	if log.ServiceName != "" && log.ServiceName != "unknown" {
		lp.stats.Services[log.ServiceName]++
	}
	if log.RouterName != "" && log.RouterName != "unknown" {
		lp.stats.Routers[log.RouterName]++
	}
	lp.stats.Methods[log.Method]++

	if log.ClientIP != "" && log.ClientIP != "unknown" {
		lp.topIPs[log.ClientIP]++
	}

	if log.RouterName != "" && log.RouterName != "unknown" {
		lp.topRouters[log.RouterName]++
	}

	if log.RequestAddr != "" {
		lp.topRequestAddrs[log.RequestAddr]++
	}

	if log.RequestHost != "" {
		lp.topRequestHosts[log.RequestHost]++
	}

	// Update country stats if already geolocated
	if log.Country != nil && log.CountryCode != nil {
		key := fmt.Sprintf("%s|%s", *log.CountryCode, *log.Country)
		lp.stats.Countries[key]++
	}

	// Update data source statistics
	if log.DataSource != "" {
		lp.stats.DataSources[log.DataSource]++
	}

	// Update total data transmitted
	lp.totalDataTransmitted += int64(log.Size)
	
	// Parse timestamp and update oldest/newest
	if timestamp, err := time.Parse(time.RFC3339, log.Timestamp); err == nil {
		if lp.oldestLogTime.IsZero() || timestamp.Before(lp.oldestLogTime) {
			lp.oldestLogTime = timestamp
		}
		if lp.newestLogTime.IsZero() || timestamp.After(lp.newestLogTime) {
			lp.newestLogTime = timestamp
		}
	}

	// Update average response time
	totalResponseTime := 0.0
	count := 0
	for i := range lp.logs {
		if i < 100 { // Only calculate for last 100 logs for performance
			totalResponseTime += lp.logs[i].ResponseTime
			count++
		}
	}
	if count > 0 {
		lp.stats.AvgResponseTime = totalResponseTime / float64(count)
	}

	// Update requests per second
	now := time.Now()
	if now.Sub(lp.lastTimestamp) >= time.Second {
		lp.stats.RequestsPerSecond = lp.requestsInLastSecond
		lp.requestsInLastSecond = 0
		lp.lastTimestamp = now
	}
	lp.requestsInLastSecond++
}

func (lp *LogParser) GetStats() Stats {
	lp.mu.RLock()
	defer lp.mu.RUnlock()

	// Create deep copies of all maps to prevent concurrent access issues
	stats := Stats{
		TotalRequests:        lp.stats.TotalRequests,
		StatusCodes:          make(map[int]int),
		Services:            make(map[string]int),
		Routers:             make(map[string]int),
		Methods:             make(map[string]int),
		AvgResponseTime:     lp.stats.AvgResponseTime,
		Requests5xx:         lp.stats.Requests5xx,
		Requests4xx:         lp.stats.Requests4xx,
		Requests2xx:         lp.stats.Requests2xx,
		RequestsPerSecond:  lp.stats.RequestsPerSecond,
		Countries:           make(map[string]int),
		GeoProcessingRemaining: len(lp.geoProcessingQueue),
		TotalDataTransmitted: lp.totalDataTransmitted,
		OldestLogTime:       lp.stats.OldestLogTime,
		NewestLogTime:       lp.stats.NewestLogTime,
		AnalysisPeriod:     lp.stats.AnalysisPeriod,
		OTLPRequests:        lp.otlpRequestCount,
		LogFileRequests:     lp.logFileRequestCount,
		DataSources:         make(map[string]int),
	}
	
	// Deep copy all maps
	for k, v := range lp.stats.StatusCodes {
		stats.StatusCodes[k] = v
	}
	for k, v := range lp.stats.Services {
		stats.Services[k] = v
	}
	for k, v := range lp.stats.Routers {
		stats.Routers[k] = v
	}
	for k, v := range lp.stats.Methods {
		stats.Methods[k] = v
	}
	for k, v := range lp.stats.Countries {
		stats.Countries[k] = v
	}
	for source, count := range lp.dataSourceCounts {
		stats.DataSources[source] = count
	}
	
	// Format timestamps
	if !lp.oldestLogTime.IsZero() {
		stats.OldestLogTime = lp.oldestLogTime.Format(time.RFC3339)
	}
	if !lp.newestLogTime.IsZero() {
		stats.NewestLogTime = lp.newestLogTime.Format(time.RFC3339)
	}
	
	// Calculate analysis period
	if !lp.oldestLogTime.IsZero() && !lp.newestLogTime.IsZero() {
		duration := lp.newestLogTime.Sub(lp.oldestLogTime)
		if duration < time.Minute {
			stats.AnalysisPeriod = fmt.Sprintf("%.0f seconds", duration.Seconds())
		} else if duration < time.Hour {
			stats.AnalysisPeriod = fmt.Sprintf("%.1f minutes", duration.Minutes())
		} else if duration < 24*time.Hour {
			stats.AnalysisPeriod = fmt.Sprintf("%.1f hours", duration.Hours())
		} else {
			stats.AnalysisPeriod = fmt.Sprintf("%.1f days", duration.Hours()/24)
		}
	}

	// Get top IPs
	stats.TopIPs = getTopItems(lp.topIPs, 10, func(k string, v int) IPCount {
		return IPCount{IP: k, Count: v}
	})

	// Get ALL countries for the map
	countries := make([]CountryCount, 0)
	for key, count := range lp.stats.Countries {
		parts := strings.Split(key, "|")
		if len(parts) == 2 {
			countries = append(countries, CountryCount{
				CountryCode: parts[0],
				Country:     parts[1],
				Count:       count,
			})
		}
	}
	sort.Slice(countries, func(i, j int) bool {
		return countries[i].Count > countries[j].Count
	})
	stats.TopCountries = countries

	// Get top routers
	stats.TopRouters = getTopItems(lp.topRouters, 10, func(k string, v int) RouterCount {
		return RouterCount{Router: k, Count: v}
	})

	// Get top request addresses
	stats.TopRequestAddrs = getTopItems(lp.topRequestAddrs, 10, func(k string, v int) AddrCount {
		return AddrCount{Addr: k, Count: v}
	})

	// Get top request hosts
	stats.TopRequestHosts = getTopItems(lp.topRequestHosts, 10, func(k string, v int) HostCount {
		return HostCount{Host: k, Count: v}
	})

	stats.AvgResponseTime = math.Round(stats.AvgResponseTime*100) / 100

	return stats
}

func (lp *LogParser) GetLogs(params LogsParams) LogsResult {
	lp.mu.RLock()
	filteredLogs := make([]LogEntry, 0, len(lp.logs))
	
	for _, log := range lp.logs {
		// Apply filters
		if params.Filters.Service != "" && log.ServiceName != params.Filters.Service {
			continue
		}
		if params.Filters.Status != "" {
			if status, err := strconv.Atoi(params.Filters.Status); err == nil && log.Status != status {
				continue
			}
		}
		if params.Filters.Router != "" && log.RouterName != params.Filters.Router {
			continue
		}
		if params.Filters.HideUnknown && (log.ServiceName == "unknown" || log.RouterName == "unknown") {
			continue
		}
		if params.Filters.HidePrivateIPs && lp.isPrivateIP(log.ClientIP) {
			continue
		}
		// New: Data source filter
		if params.Filters.DataSource != "" && params.Filters.DataSource != "all" && log.DataSource != params.Filters.DataSource {
			continue
		}
		
		filteredLogs = append(filteredLogs, log)
	}
	lp.mu.RUnlock()

	// Pagination
	start := (params.Page - 1) * params.Limit
	end := start + params.Limit
	if end > len(filteredLogs) {
		end = len(filteredLogs)
	}
	if start > len(filteredLogs) {
		start = len(filteredLogs)
	}

	paginatedLogs := filteredLogs[start:end]

	// Try to geolocate logs without location data (on-demand for display)
	for i := range paginatedLogs {
		if paginatedLogs[i].Country == nil && paginatedLogs[i].ClientIP != "" && !lp.isPrivateIP(paginatedLogs[i].ClientIP) {
			geoData := GetGeoLocation(paginatedLogs[i].ClientIP)
			if geoData != nil {
				paginatedLogs[i].Country = &geoData.Country
				paginatedLogs[i].City = &geoData.City
				paginatedLogs[i].CountryCode = &geoData.CountryCode
				paginatedLogs[i].Lat = &geoData.Lat
				paginatedLogs[i].Lon = &geoData.Lon
			}
		}
	}

	return LogsResult{
		Logs:       paginatedLogs,
		Total:      len(filteredLogs),
		Page:       params.Page,
		TotalPages: int(math.Ceil(float64(len(filteredLogs)) / float64(params.Limit))),
	}
}

func (lp *LogParser) GetServices() []string {
	lp.mu.RLock()
	defer lp.mu.RUnlock()

	services := make([]string, 0, len(lp.stats.Services))
	for service := range lp.stats.Services {
		services = append(services, service)
	}
	sort.Strings(services)
	return services
}

func (lp *LogParser) GetRouters() []string {
	lp.mu.RLock()
	defer lp.mu.RUnlock()

	routers := make([]string, 0, len(lp.stats.Routers))
	for router := range lp.stats.Routers {
		routers = append(routers, router)
	}
	sort.Strings(routers)
	return routers
}

func (lp *LogParser) GetGeoStats() GeoStats {
	lp.mu.RLock()
	defer lp.mu.RUnlock()

	// Create a deep copy of the countries map to prevent concurrent access
	countriesMap := make(map[string]int)
	for key, count := range lp.stats.Countries {
		countriesMap[key] = count
	}
	
	countries := make([]CountryCount, 0)
	for key, count := range countriesMap {
		parts := strings.Split(key, "|")
		if len(parts) == 2 {
			countries = append(countries, CountryCount{
				CountryCode: parts[0],
				Country:     parts[1],
				Count:       count,
			})
		}
	}
	sort.Slice(countries, func(i, j int) bool {
		return countries[i].Count > countries[j].Count
	})

	return GeoStats{
		Countries:              countries,
		TotalCountries:         len(countries),
		GeoProcessingRemaining: len(lp.geoProcessingQueue),
	}
}

func (lp *LogParser) IsProcessingGeo() bool {
	lp.mu.RLock()
	defer lp.mu.RUnlock()
	return lp.isProcessingGeo
}

// Get OTLP-specific statistics
func (lp *LogParser) GetOTLPStats() map[string]interface{} {
	lp.mu.RLock()
	defer lp.mu.RUnlock()
	
	// Create a deep copy of the data sources map
	dataSourcesCopy := make(map[string]int)
	for source, count := range lp.dataSourceCounts {
		dataSourcesCopy[source] = count
	}
	
	return map[string]interface{}{
		"otlpRequests":       lp.otlpRequestCount,
		"logFileRequests":    lp.logFileRequestCount,
		"totalRequests":      lp.stats.TotalRequests,
		"dataSources":        dataSourcesCopy,
		"otlpPercentage":     func() float64 {
			if lp.stats.TotalRequests == 0 {
				return 0.0
			}
			return float64(lp.otlpRequestCount) / float64(lp.stats.TotalRequests) * 100
		}(),
	}
}

func (lp *LogParser) startGeoProcessing() {
	lp.mu.Lock()
	if lp.isProcessingGeo {
		lp.mu.Unlock()
		return
	}
	lp.isProcessingGeo = true
	lp.mu.Unlock()

	log.Println("Starting background geo processing...")

	for {
		select {
		case <-lp.geoStopChan:
			log.Println("Geo processing stopped")
			return
		default:
			lp.mu.Lock()
			if len(lp.geoProcessingQueue) == 0 {
				lp.isProcessingGeo = false
				lp.mu.Unlock()
				time.Sleep(5 * time.Second) // Wait before checking again
				continue
			}

			// Process up to 40 IPs at a time
			batchSize := 40
			if len(lp.geoProcessingQueue) < batchSize {
				batchSize = len(lp.geoProcessingQueue)
			}
			ipBatch := lp.geoProcessingQueue[:batchSize]
			lp.geoProcessingQueue = lp.geoProcessingQueue[batchSize:]
			lp.mu.Unlock()

			// Process each IP in the batch
			for _, ip := range ipBatch {
				geoData := GetGeoLocation(ip)
				if geoData != nil {
					lp.mu.Lock()
					
					// Update country stats
					key := fmt.Sprintf("%s|%s", geoData.CountryCode, geoData.Country)
					
					// Update all logs with this IP
					updatedCount := 0
					for i := range lp.logs {
						if lp.logs[i].ClientIP == ip && lp.logs[i].Country == nil {
							lp.logs[i].Country = &geoData.Country
							lp.logs[i].City = &geoData.City
							lp.logs[i].CountryCode = &geoData.CountryCode
							lp.logs[i].Lat = &geoData.Lat
							lp.logs[i].Lon = &geoData.Lon
							updatedCount++
						}
					}
					
					if updatedCount > 0 {
						lp.stats.Countries[key] += updatedCount
					}
					
					lp.mu.Unlock()
				}
			}

			log.Printf("Processed geo data for %d IPs. %d IPs remaining in queue.", len(ipBatch), len(lp.geoProcessingQueue))

			// Rate limit - only if there are more IPs to process
			if len(lp.geoProcessingQueue) > 0 {
				time.Sleep(60 * time.Second)
			}
		}
	}
}

func (lp *LogParser) AddListener(ch chan LogEntry) {
	lp.mu.Lock()
	defer lp.mu.Unlock()
	lp.listeners = append(lp.listeners, ch)
}

func (lp *LogParser) RemoveListener(ch chan LogEntry) {
	lp.mu.Lock()
	defer lp.mu.Unlock()
	for i, listener := range lp.listeners {
		if listener == ch {
			lp.listeners = append(lp.listeners[:i], lp.listeners[i+1:]...)
			break
		}
	}
}

func (lp *LogParser) notifyListeners(log LogEntry) {
	lp.mu.RLock()
	listeners := make([]chan LogEntry, len(lp.listeners))
	copy(listeners, lp.listeners)
	lp.mu.RUnlock()
	
	for _, listener := range listeners {
		select {
		case listener <- log:
		default:
			// Don't block if listener is not ready
		}
	}
}

// Helper functions
func getStringValue(m map[string]interface{}, key, defaultValue string) string {
	if v, ok := m[key]; ok {
		if s, ok := v.(string); ok {
			return s
		}
	}
	return defaultValue
}

func getIntValue(m map[string]interface{}, key string, defaultValue int) int {
	if v, ok := m[key]; ok {
		switch v := v.(type) {
		case float64:
			return int(v)
		case int:
			return v
		case string:
			if i, err := strconv.Atoi(v); err == nil {
				return i
			}
		}
	}
	return defaultValue
}

func getInt64Value(m map[string]interface{}, key string, defaultValue int64) int64 {
	if v, ok := m[key]; ok {
		switch v := v.(type) {
		case float64:
			return int64(v)
		case int64:
			return v
		case string:
			if i, err := strconv.ParseInt(v, 10, 64); err == nil {
				return i
			}
		}
	}
	return defaultValue
}

func getFloatValue(m map[string]interface{}, key string, defaultValue float64) float64 {
	if v, ok := m[key]; ok {
		switch v := v.(type) {
		case float64:
			return v
		case int:
			return float64(v)
		case string:
			if f, err := strconv.ParseFloat(v, 64); err == nil {
				return f
			}
		}
	}
	return defaultValue
}

func getTopItems[T any](items map[string]int, limit int, converter func(string, int) T) []T {
	type kv struct {
		Key   string
		Value int
	}

	var sorted []kv
	for k, v := range items {
		sorted = append(sorted, kv{k, v})
	}
	sort.Slice(sorted, func(i, j int) bool {
		return sorted[i].Value > sorted[j].Value
	})

	result := make([]T, 0, limit)
	for i := 0; i < limit && i < len(sorted); i++ {
		result = append(result, converter(sorted[i].Key, sorted[i].Value))
	}
	return result
}

[orlovds]

@hhftechnology Maybe we can trust the AI? :)

[hhftechnology]

Almost done testing the new rewrite where you will get cli agent and dashboard

[hhftechnology]

@orlovds @dlhall111 @plakun @ovizii @milindpatel63 V2 should solve all the issues

[orlovds]

@hhftechnology Thank you so much, it's running, it's working!

[plakun]

@hhftechnology thx. Waiting for documentation fixes for new version.

[hhftechnology]

https://github.com/hhftechnology/traefik-log-dashboard/blob/main/docs/MigrationV1toV2.md