add additional metadata to message, closes #194

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
remove noisy logs from event hooks and add tests (#193 )
2025-07-15 15:59:05 +03:00 · 2025-07-10 12:51:26 +03:00 · 2025-07-02 13:21:33 +00:00 · 2025-07-02 16:20:02 +03:00 · 2025-06-30 13:11:01 +00:00 · 2025-06-30 16:08:59 +03:00
22 changed files with 1046 additions and 333 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
--- a/.github/ISSUE_TEMPLATE/feature-request---enhancement.md
+++ b/.github/ISSUE_TEMPLATE/feature-request---enhancement.md
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
--- a/.github/workflows/job_coverage.yml
+++ b/.github/workflows/job_coverage.yml
@@ -0,0 +1,53 @@
+name: coverage
+
+on:
+  push:
+    branches: [ main, v3, v4 ]
+    paths-ignore:
+      - '.github/**'
+      - '.gitea/**'
+  pull_request:
+    branches: [ main, v3, v4 ]
+
+jobs:
+
+  build:
+    if: github.server_url != 'https://github.com'
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable'
+
+    - name: test coverage
+      run: |
+        go test -v -cover ./... -covermode=count -coverprofile coverage.out -coverpkg ./...
+        go tool cover -func coverage.out -o coverage.out
+
+    - name: coverage badge
+      uses: tj-actions/coverage-badge-go@v2
+      with:
+        green: 80
+        filename: coverage.out
+
+    - uses: stefanzweifel/git-auto-commit-action@v4
+      name: autocommit
+      with:
+        commit_message: Apply Code Coverage Badge
+        skip_fetch: false
+        skip_checkout: false
+        file_pattern: ./README.md
+
+    - name: push
+      if: steps.auto-commit-action.outputs.changes_detected == 'true'
+      uses: ad-m/github-push-action@master
+      with:
+        github_token: ${{ github.token }}
+        branch: ${{ github.ref }}
--- a/.github/workflows/job_lint.yml
+++ b/.github/workflows/job_lint.yml
@@ -3,10 +3,10 @@ name: lint
 on:
  pull_request:
    types: [opened, reopened, synchronize]
-    branches:
-    - master
-    - v3
-    - v4
+    branches: [ master, v3, v4 ]
+    paths-ignore:
+      - '.github/**'
+      - '.gitea/**'

 jobs:
  lint:
@@ -24,6 +24,6 @@ jobs:
    - name: setup deps
      run: go get -v ./...
    - name: run lint
-      uses: https://github.com/golangci/golangci-lint-action@v6
+      uses: golangci/golangci-lint-action@v6
      with:
        version: 'latest'
--- a/.github/workflows/job_sync.yml
+++ b/.github/workflows/job_sync.yml
@@ -0,0 +1,94 @@
+name: sync
+
+on:
+  schedule:
+    - cron: '*/5 * * * *'
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync:
+    if: github.server_url != 'https://github.com'
+    runs-on: ubuntu-latest
+    steps:
+    - name: init
+      run: |
+        git config --global user.email "vtolstov <vtolstov@users.noreply.github.com>"
+        git config --global user.name "github-actions[bot]"
+        echo "machine git.unistack.org login vtolstov password ${{ secrets.TOKEN_GITEA }}" >> /root/.netrc
+        echo "machine github.com login vtolstov password ${{ secrets.TOKEN_GITHUB }}" >> /root/.netrc
+
+    - name: check master
+      id: check_master
+      run: |
+        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/master | cut -f1)
+        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/master | cut -f1)
+        echo "src_hash=$src_hash"
+        echo "dst_hash=$dst_hash"
+        if [ "$src_hash" != "$dst_hash" ]; then
+          echo "sync_needed=true" >> $GITHUB_OUTPUT
+        else
+          echo "sync_needed=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: sync master
+      if: steps.check_master.outputs.sync_needed == 'true'
+      run: |
+        git clone --filter=blob:none --filter=tree:0 --branch master --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
+        cd repo
+        git remote add --no-tags --fetch --track master upstream https://github.com/${GITHUB_REPOSITORY}
+        git pull --rebase upstream master
+        git push upstream master --progress
+        git push origin master --progress
+        cd ../
+        rm -rf repo
+
+    - name: check v3
+      id: check_v3
+      run: |
+        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/v3 | cut -f1)
+        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/v3 | cut -f1)
+        echo "src_hash=$src_hash"
+        echo "dst_hash=$dst_hash"
+        if [ "$src_hash" != "$dst_hash" ]; then
+          echo "sync_needed=true" >> $GITHUB_OUTPUT
+        else
+          echo "sync_needed=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: sync v3
+      if: steps.check_v3.outputs.sync_needed == 'true'
+      run: |
+        git clone --filter=blob:none --filter=tree:0 --branch v3 --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
+        cd repo
+        git remote add --no-tags --fetch --track v3 upstream https://github.com/${GITHUB_REPOSITORY}
+        git pull --rebase upstream v3
+        git push upstream v3 --progress
+        git push origin v3 --progress
+        cd ../
+        rm -rf repo
+
+    - name: check v4
+      id: check_v4
+      run: |
+        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/v4 | cut -f1)
+        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/v4 | cut -f1)
+        echo "src_hash=$src_hash"
+        echo "dst_hash=$dst_hash"
+        if [ "$src_hash" != "$dst_hash" ]; then
+          echo "sync_needed=true" >> $GITHUB_OUTPUT
+        else
+          echo "sync_needed=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: sync v4
+      if: steps.check_v4.outputs.sync_needed == 'true'
+      run: |
+        git clone --filter=blob:none --filter=tree:0 --branch v4 --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
+        cd repo
+        git remote add --no-tags --fetch --track v4 upstream https://github.com/${GITHUB_REPOSITORY}
+        git pull --rebase upstream v4
+        git push upstream v4 --progress
+        git push origin v4 --progress
+        cd ../
+        rm -rf repo
--- a/.github/workflows/job_test.yml
+++ b/.github/workflows/job_test.yml
@@ -3,15 +3,12 @@ name: test
 on:
  pull_request:
    types: [opened, reopened, synchronize]
-    branches:
-    - master
-    - v3
-    - v4
+    branches: [ master, v3, v4 ]
  push:
-    branches:
-    - master
-    - v3
-    - v4
+    branches: [ master, v3, v4 ]
+    paths-ignore:
+      - '.github/**'
+      - '.gitea/**'

 jobs:
  test:
--- a/.github/workflows/job_tests.yml
+++ b/.github/workflows/job_tests.yml
@@ -3,15 +3,12 @@ name: test
 on:
  pull_request:
    types: [opened, reopened, synchronize]
-    branches:
-    - master
-    - v3
-    - v4
+    branches: [ master, v3, v4 ]
  push:
-    branches:
-    - master
-    - v3
-    - v4
+    branches: [ master, v3, v4 ]
+    paths-ignore:
+      - '.github/**'
+      - '.gitea/**'

 jobs:
  test:
@@ -35,19 +32,19 @@ jobs:
        go-version: 'stable'
    - name: setup go work
      env:
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+        GOWORK: ${{ github.workspace }}/go.work
      run: |
        go work init
        go work use .
        go work use micro-tests
    - name: setup deps
      env:
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+        GOWORK: ${{ github.workspace }}/go.work
      run: go get -v ./...
    - name: run tests
      env:
        INTEGRATION_TESTS: yes
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+        GOWORK: ${{ github.workspace }}/go.work
      run: |
        cd micro-tests
        go test -mod readonly -v ./... || true
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,21 +1,5 @@
 run:
  concurrency: 8
-  deadline: 5m
+  timeout: 5m
  issues-exit-code: 1
  tests: true
-
-linters:
-  enable:
-    - staticcheck
-    - unused
-    - gosimple
-    - govet
-    - prealloc
-    - unconvert
-    - nakedret
-
-linters-settings:
-  govet:
-    check-all: true
-    enable:
-      - fieldalignment
--- a/README.md
+++ b/README.md
@@ -1,9 +1,2 @@
-# broker-kgo
-
-TODO:
-
-1) экспортируем текущий оффсет для каждой партиции в группе
-2) экспортируем лаг для группы
-3) мониторим
-   1) если есть лаг больше нуля
-   2) если дельта оффсета за нужное нам время не 
+# micro-broker-kgo
+![Coverage](https://img.shields.io/badge/Coverage-63.1%25-yellow)
--- a/broker.go
+++ b/broker.go
@@ -1,69 +0,0 @@
-package kgo
-
-import (
-	"context"
-	"net"
-	"sync/atomic"
-	"time"
-
-	"github.com/twmb/franz-go/pkg/kgo"
-	"go.unistack.org/micro/v4/logger"
-)
-
-type hookEvent struct {
-	log          logger.Logger
-	fatalOnError bool
-	connected    *atomic.Uint32
-}
-
-var (
-	_ kgo.HookBrokerConnect           = &hookEvent{}
-	_ kgo.HookBrokerDisconnect        = &hookEvent{}
-	_ kgo.HookBrokerRead              = &hookEvent{}
-	_ kgo.HookBrokerWrite             = &hookEvent{}
-	_ kgo.HookGroupManageError        = &hookEvent{}
-	_ kgo.HookProduceRecordUnbuffered = &hookEvent{}
-)
-
-func (m *hookEvent) OnGroupManageError(err error) {
-	if err != nil {
-		m.connected.Store(0)
-		if m.fatalOnError {
-			m.log.Fatal(context.TODO(), "kgo.OnGroupManageError", err)
-		}
-	}
-}
-
-func (m *hookEvent) OnBrokerConnect(_ kgo.BrokerMetadata, _ time.Duration, _ net.Conn, err error) {
-	if err != nil {
-		m.connected.Store(0)
-		if m.fatalOnError {
-			m.log.Fatal(context.TODO(), "kgo.OnBrokerConnect", err)
-		}
-	}
-}
-
-func (m *hookEvent) OnBrokerDisconnect(_ kgo.BrokerMetadata, _ net.Conn) {
-	m.connected.Store(0)
-}
-
-func (m *hookEvent) OnBrokerWrite(_ kgo.BrokerMetadata, _ int16, _ int, _ time.Duration, _ time.Duration, err error) {
-	if err != nil {
-		m.connected.Store(0)
-		if m.fatalOnError {
-			m.log.Fatal(context.TODO(), "kgo.OnBrokerWrite", err)
-		}
-	}
-}
-
-func (m *hookEvent) OnBrokerRead(_ kgo.BrokerMetadata, _ int16, _ int, _ time.Duration, _ time.Duration, err error) {
-	if err != nil {
-		m.connected.Store(0)
-	}
-}
-
-func (m *hookEvent) OnProduceRecordUnbuffered(_ *kgo.Record, err error) {
-	if err != nil {
-		m.connected.Store(0)
-	}
-}
--- a/errors.go
+++ b/errors.go
@@ -0,0 +1,10 @@
+package kgo
+
+import (
+	"context"
+	"errors"
+)
+
+func isContextError(err error) bool {
+	return errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)
+}
--- a/go.mod
+++ b/go.mod
@@ -1,24 +1,27 @@
 module go.unistack.org/micro-broker-kgo/v4

-go 1.23.0
+go 1.23.8

 require (
-	github.com/twmb/franz-go v1.18.1
-	github.com/twmb/franz-go/pkg/kadm v1.15.0
-	github.com/twmb/franz-go/pkg/kmsg v1.9.0
-	go.opentelemetry.io/otel v1.34.0
-	go.unistack.org/micro/v4 v4.1.4
+	github.com/stretchr/testify v1.10.0
+	github.com/twmb/franz-go v1.19.5
+	github.com/twmb/franz-go/pkg/kadm v1.16.0
+	github.com/twmb/franz-go/pkg/kfake v0.0.0-20250508175730-72e1646135e3
+	github.com/twmb/franz-go/pkg/kmsg v1.11.2
+	go.opentelemetry.io/otel v1.36.0
+	go.unistack.org/micro/v4 v4.1.17
 )

 require (
-	github.com/ash3in/uuidv8 v1.2.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/matoous/go-nanoid v1.5.1 // indirect
 	github.com/pierrec/lz4/v4 v4.1.22 // indirect
-	github.com/spf13/cast v1.7.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/spf13/cast v1.9.2 // indirect
 	go.unistack.org/micro-proto/v4 v4.1.0 // indirect
-	golang.org/x/crypto v0.36.0 // indirect
-	google.golang.org/protobuf v1.36.5 // indirect
+	golang.org/x/crypto v0.39.0 // indirect
+	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,13 +1,9 @@
-github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
-github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
-github.com/ash3in/uuidv8 v1.2.0 h1:2oogGdtCPwaVtyvPPGin4TfZLtOGE5F+W++E880G6SI=
-github.com/ash3in/uuidv8 v1.2.0/go.mod h1:BnU0wJBxnzdEKmVg4xckBkD+VZuecTFTUP3M0dWgyY4=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
@@ -24,26 +20,28 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
-github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
+github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/twmb/franz-go v1.18.1 h1:D75xxCDyvTqBSiImFx2lkPduE39jz1vaD7+FNc+vMkc=
-github.com/twmb/franz-go v1.18.1/go.mod h1:Uzo77TarcLTUZeLuGq+9lNpSkfZI+JErv7YJhlDjs9M=
-github.com/twmb/franz-go/pkg/kadm v1.15.0 h1:Yo3NAPfcsx3Gg9/hdhq4vmwO77TqRRkvpUcGWzjworc=
-github.com/twmb/franz-go/pkg/kadm v1.15.0/go.mod h1:MUdcUtnf9ph4SFBLLA/XxE29rvLhWYLM9Ygb8dfSCvw=
-github.com/twmb/franz-go/pkg/kmsg v1.9.0 h1:JojYUph2TKAau6SBtErXpXGC7E3gg4vGZMv9xFU/B6M=
-github.com/twmb/franz-go/pkg/kmsg v1.9.0/go.mod h1:CMbfazviCyY6HM0SXuG5t9vOwYDHRCSrJJyBAe5paqg=
-go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
-go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+github.com/twmb/franz-go v1.19.5 h1:W7+o8D0RsQsedqib71OVlLeZ0zI6CbFra7yTYhZTs5Y=
+github.com/twmb/franz-go v1.19.5/go.mod h1:4kFJ5tmbbl7asgwAGVuyG1ZMx0NNpYk7EqflvWfPCpM=
+github.com/twmb/franz-go/pkg/kadm v1.16.0 h1:STMs1t5lYR5mR974PSiwNzE5TvsosByTp+rKXLOhAjE=
+github.com/twmb/franz-go/pkg/kadm v1.16.0/go.mod h1:MUdcUtnf9ph4SFBLLA/XxE29rvLhWYLM9Ygb8dfSCvw=
+github.com/twmb/franz-go/pkg/kfake v0.0.0-20250508175730-72e1646135e3 h1:p24opKWPySAy8xSl8NqRgOv7Q+bX7kdrQirBVRJzQfo=
+github.com/twmb/franz-go/pkg/kfake v0.0.0-20250508175730-72e1646135e3/go.mod h1:7uQs3Ae6HkWT1Y9elMbqtAcNFCI0y6+iS+Phw49L49U=
+github.com/twmb/franz-go/pkg/kmsg v1.11.2 h1:hIw75FpwcAjgeyfIGFqivAvwC5uNIOWRGvQgZhH4mhg=
+github.com/twmb/franz-go/pkg/kmsg v1.11.2/go.mod h1:CFfkkLysDNmukPYhGzuUcDtf46gQSqCZHMW1T4Z+wDE=
+go.opentelemetry.io/otel v1.36.0 h1:UumtzIklRBY6cI/lllNZlALOF5nNIzJVb16APdvgTXg=
+go.opentelemetry.io/otel v1.36.0/go.mod h1:/TcFMXYjyRNh8khOAO9ybYkqaDBb/70aVwkNML4pP8E=
 go.unistack.org/micro-proto/v4 v4.1.0 h1:qPwL2n/oqh9RE3RTTDgt28XK3QzV597VugQPaw9lKUk=
 go.unistack.org/micro-proto/v4 v4.1.0/go.mod h1:ArmK7o+uFvxSY3dbJhKBBX4Pm1rhWdLEFf3LxBrMtec=
-go.unistack.org/micro/v4 v4.1.4 h1:gyjVPP9g7UAFZlhEbla9Ih/BeKJfBLAbN/NvAhJCpKU=
-go.unistack.org/micro/v4 v4.1.4/go.mod h1:lr3oYED8Ay1vjK68QqRw30QOtdk/ffpZqMFDasOUhKw=
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
-google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+go.unistack.org/micro/v4 v4.1.17 h1:26QDtRSYVpozYuassyvLP4sEQRo3dxgD3sVILRXmIPo=
+go.unistack.org/micro/v4 v4.1.17/go.mod h1:xleO2M5Yxh4s6I+RUcLrEpUjobefh+71ctrdIfn7TUs=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
--- a/hook_event.go
+++ b/hook_event.go
@@ -0,0 +1,108 @@
+package kgo
+
+import (
+	"context"
+	"net"
+	"sync/atomic"
+	"time"
+
+	"github.com/twmb/franz-go/pkg/kgo"
+	"go.unistack.org/micro/v4/logger"
+)
+
+type hookEvent struct {
+	log          logger.Logger
+	fatalOnError bool
+	connected    *atomic.Uint32
+}
+
+var (
+	_ kgo.HookBrokerConnect           = &hookEvent{}
+	_ kgo.HookBrokerDisconnect        = &hookEvent{}
+	_ kgo.HookBrokerRead              = &hookEvent{}
+	_ kgo.HookBrokerWrite             = &hookEvent{}
+	_ kgo.HookGroupManageError        = &hookEvent{}
+	_ kgo.HookProduceRecordUnbuffered = &hookEvent{}
+)
+
+func (m *hookEvent) OnGroupManageError(err error) {
+	switch {
+	case err == nil || isContextError(err) || kgo.IsRetryableBrokerErr(err):
+		return
+	default:
+		ctx := context.TODO()
+		logMsg := "kgo.OnGroupManageError"
+
+		if m.fatalOnError {
+			m.log.Fatal(ctx, logMsg, err)
+		} else {
+			m.log.Error(ctx, logMsg, err)
+		}
+	}
+}
+
+func (m *hookEvent) OnBrokerConnect(_ kgo.BrokerMetadata, _ time.Duration, _ net.Conn, err error) {
+	switch {
+	case err == nil || isContextError(err) || kgo.IsRetryableBrokerErr(err):
+		return
+	default:
+		ctx := context.TODO()
+		logMsg := "kgo.OnBrokerConnect"
+
+		if m.fatalOnError {
+			m.log.Fatal(ctx, logMsg, err)
+		} else {
+			m.log.Error(ctx, logMsg, err)
+		}
+	}
+}
+
+func (m *hookEvent) OnBrokerDisconnect(_ kgo.BrokerMetadata, _ net.Conn) {}
+
+func (m *hookEvent) OnBrokerWrite(_ kgo.BrokerMetadata, _ int16, _ int, _ time.Duration, _ time.Duration, err error) {
+	switch {
+	case err == nil || isContextError(err) || kgo.IsRetryableBrokerErr(err):
+		return
+	default:
+		ctx := context.TODO()
+		logMsg := "kgo.OnBrokerWrite"
+
+		if m.fatalOnError {
+			m.log.Fatal(ctx, logMsg, err)
+		} else {
+			m.log.Error(ctx, logMsg, err)
+		}
+	}
+}
+
+func (m *hookEvent) OnBrokerRead(_ kgo.BrokerMetadata, _ int16, _ int, _ time.Duration, _ time.Duration, err error) {
+	switch {
+	case err == nil || isContextError(err) || kgo.IsRetryableBrokerErr(err):
+		return
+	default:
+		ctx := context.TODO()
+		logMsg := "kgo.OnBrokerRead"
+
+		if m.fatalOnError {
+			m.log.Fatal(ctx, logMsg, err)
+		} else {
+			m.log.Error(ctx, logMsg, err)
+		}
+	}
+}
+
+func (m *hookEvent) OnProduceRecordUnbuffered(_ *kgo.Record, err error) {
+	switch {
+	case err == nil || isContextError(err) || kgo.IsRetryableBrokerErr(err):
+		return
+	default:
+		ctx := context.TODO()
+		logMsg := "kgo.OnProduceRecordUnbuffered"
+
+		if m.fatalOnError {
+			m.log.Fatal(ctx, logMsg, err)
+		} else {
+			m.log.Error(ctx, logMsg, err)
+		}
+	}
+}
--- a/hook_event_test.go
+++ b/hook_event_test.go
@@ -0,0 +1,471 @@
+package kgo
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/twmb/franz-go/pkg/kgo"
+	"go.unistack.org/micro/v4/logger"
+)
+
+func TestHookEvent_OnGroupManageError(t *testing.T) {
+	tests := []struct {
+		name                  string
+		inputErr              error
+		fatalOnError          bool
+		expectedErrorIsCalled bool
+		expectedErrorMsg      string
+		expectedFatalIsCalled bool
+		expectedFatalMsg      string
+	}{
+		{
+			name:                  "error is nil",
+			inputErr:              nil,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context canceled",
+			inputErr:              context.Canceled,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context deadline exceeded",
+			inputErr:              context.DeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: deadline exceeded (os package)",
+			inputErr:              os.ErrDeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: EOF (io package)",
+			inputErr:              io.EOF,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: closed network connection (net package)",
+			inputErr:              net.ErrClosed,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (non-fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          false,
+			expectedErrorIsCalled: true,
+			expectedErrorMsg:      "kgo.OnGroupManageError",
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          true,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: true,
+			expectedFatalMsg:      "kgo.OnGroupManageError",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			log := &mockLogger{}
+			he := &hookEvent{log: log, fatalOnError: tt.fatalOnError}
+			he.OnGroupManageError(tt.inputErr)
+			require.Equal(t, tt.expectedErrorIsCalled, log.errorIsCalled)
+			require.Equal(t, tt.expectedErrorMsg, log.errorMsg)
+			require.Equal(t, tt.expectedFatalIsCalled, log.fatalIsCalled)
+			require.Equal(t, tt.expectedFatalMsg, log.fatalMsg)
+		})
+	}
+}
+
+func TestHookEvent_OnBrokerConnect(t *testing.T) {
+	tests := []struct {
+		name                  string
+		inputErr              error
+		fatalOnError          bool
+		expectedErrorIsCalled bool
+		expectedErrorMsg      string
+		expectedFatalIsCalled bool
+		expectedFatalMsg      string
+	}{
+		{
+			name:                  "error is nil",
+			inputErr:              nil,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context canceled",
+			inputErr:              context.Canceled,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context deadline exceeded",
+			inputErr:              context.DeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: deadline exceeded (os package)",
+			inputErr:              os.ErrDeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: EOF (io package)",
+			inputErr:              io.EOF,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: closed network connection (net package)",
+			inputErr:              net.ErrClosed,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (non-fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          false,
+			expectedErrorIsCalled: true,
+			expectedErrorMsg:      "kgo.OnBrokerConnect",
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          true,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: true,
+			expectedFatalMsg:      "kgo.OnBrokerConnect",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			log := &mockLogger{}
+			he := &hookEvent{log: log, fatalOnError: tt.fatalOnError}
+			he.OnBrokerConnect(kgo.BrokerMetadata{}, 0, nil, tt.inputErr)
+			require.Equal(t, tt.expectedErrorIsCalled, log.errorIsCalled)
+			require.Equal(t, tt.expectedErrorMsg, log.errorMsg)
+			require.Equal(t, tt.expectedFatalIsCalled, log.fatalIsCalled)
+			require.Equal(t, tt.expectedFatalMsg, log.fatalMsg)
+		})
+	}
+}
+
+func TestHookEvent_OnBrokerWrite(t *testing.T) {
+	tests := []struct {
+		name                  string
+		inputErr              error
+		fatalOnError          bool
+		expectedErrorIsCalled bool
+		expectedErrorMsg      string
+		expectedFatalIsCalled bool
+		expectedFatalMsg      string
+	}{
+		{
+			name:                  "error is nil",
+			inputErr:              nil,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context canceled",
+			inputErr:              context.Canceled,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context deadline exceeded",
+			inputErr:              context.DeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: deadline exceeded (os package)",
+			inputErr:              os.ErrDeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: EOF (io package)",
+			inputErr:              io.EOF,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: closed network connection (net package)",
+			inputErr:              net.ErrClosed,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (non-fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          false,
+			expectedErrorIsCalled: true,
+			expectedErrorMsg:      "kgo.OnBrokerWrite",
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          true,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: true,
+			expectedFatalMsg:      "kgo.OnBrokerWrite",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			log := &mockLogger{}
+			he := &hookEvent{log: log, fatalOnError: tt.fatalOnError}
+			he.OnBrokerWrite(kgo.BrokerMetadata{}, 0, 0, 0, 0, tt.inputErr)
+			require.Equal(t, tt.expectedErrorIsCalled, log.errorIsCalled)
+			require.Equal(t, tt.expectedErrorMsg, log.errorMsg)
+			require.Equal(t, tt.expectedFatalIsCalled, log.fatalIsCalled)
+			require.Equal(t, tt.expectedFatalMsg, log.fatalMsg)
+		})
+	}
+}
+
+func TestHookEvent_OnBrokerRead(t *testing.T) {
+	tests := []struct {
+		name                  string
+		inputErr              error
+		fatalOnError          bool
+		expectedErrorIsCalled bool
+		expectedErrorMsg      string
+		expectedFatalIsCalled bool
+		expectedFatalMsg      string
+	}{
+		{
+			name:                  "error is nil",
+			inputErr:              nil,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context canceled",
+			inputErr:              context.Canceled,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context deadline exceeded",
+			inputErr:              context.DeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: deadline exceeded (os package)",
+			inputErr:              os.ErrDeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: EOF (io package)",
+			inputErr:              io.EOF,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: closed network connection (net package)",
+			inputErr:              net.ErrClosed,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (non-fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          false,
+			expectedErrorIsCalled: true,
+			expectedErrorMsg:      "kgo.OnBrokerRead",
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          true,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: true,
+			expectedFatalMsg:      "kgo.OnBrokerRead",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			log := &mockLogger{}
+			he := &hookEvent{log: log, fatalOnError: tt.fatalOnError}
+			he.OnBrokerRead(kgo.BrokerMetadata{}, 0, 0, 0, 0, tt.inputErr)
+			require.Equal(t, tt.expectedErrorIsCalled, log.errorIsCalled)
+			require.Equal(t, tt.expectedErrorMsg, log.errorMsg)
+			require.Equal(t, tt.expectedFatalIsCalled, log.fatalIsCalled)
+			require.Equal(t, tt.expectedFatalMsg, log.fatalMsg)
+		})
+	}
+}
+
+func TestHookEvent_OnProduceRecordUnbuffered(t *testing.T) {
+	tests := []struct {
+		name                  string
+		inputErr              error
+		fatalOnError          bool
+		expectedErrorIsCalled bool
+		expectedErrorMsg      string
+		expectedFatalIsCalled bool
+		expectedFatalMsg      string
+	}{
+		{
+			name:                  "error is nil",
+			inputErr:              nil,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context canceled",
+			inputErr:              context.Canceled,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "context deadline exceeded",
+			inputErr:              context.DeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: deadline exceeded (os package)",
+			inputErr:              os.ErrDeadlineExceeded,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: EOF (io package)",
+			inputErr:              io.EOF,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "retryable error: closed network connection (net package)",
+			inputErr:              net.ErrClosed,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (non-fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          false,
+			expectedErrorIsCalled: true,
+			expectedErrorMsg:      "kgo.OnProduceRecordUnbuffered",
+			expectedFatalIsCalled: false,
+		},
+		{
+			name:                  "some error (fatal)",
+			inputErr:              errors.New("some error"),
+			fatalOnError:          true,
+			expectedErrorIsCalled: false,
+			expectedFatalIsCalled: true,
+			expectedFatalMsg:      "kgo.OnProduceRecordUnbuffered",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			log := &mockLogger{}
+			he := &hookEvent{log: log, fatalOnError: tt.fatalOnError}
+			he.OnProduceRecordUnbuffered(&kgo.Record{}, tt.inputErr)
+			require.Equal(t, tt.expectedErrorIsCalled, log.errorIsCalled)
+			require.Equal(t, tt.expectedErrorMsg, log.errorMsg)
+			require.Equal(t, tt.expectedFatalIsCalled, log.fatalIsCalled)
+			require.Equal(t, tt.expectedFatalMsg, log.fatalMsg)
+		})
+	}
+}
+
+// Mocks
+
+type mockLogger struct {
+	errorIsCalled bool
+	errorMsg      string
+
+	fatalIsCalled bool
+	fatalMsg      string
+}
+
+func (m *mockLogger) Init(...logger.Option) error {
+	panic("implement me")
+}
+
+func (m *mockLogger) Clone(...logger.Option) logger.Logger {
+	panic("implement me")
+}
+
+func (m *mockLogger) V(logger.Level) bool {
+	panic("implement me")
+}
+
+func (m *mockLogger) Level(logger.Level) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Options() logger.Options {
+	panic("implement me")
+}
+
+func (m *mockLogger) Fields(...interface{}) logger.Logger {
+	panic("implement me")
+}
+
+func (m *mockLogger) Info(context.Context, string, ...interface{}) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Trace(context.Context, string, ...interface{}) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Debug(context.Context, string, ...interface{}) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Warn(context.Context, string, ...interface{}) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Error(ctx context.Context, msg string, args ...interface{}) {
+	m.errorIsCalled = true
+	m.errorMsg = msg
+}
+
+func (m *mockLogger) Fatal(ctx context.Context, msg string, args ...interface{}) {
+	m.fatalIsCalled = true
+	m.fatalMsg = msg
+}
+
+func (m *mockLogger) Log(context.Context, logger.Level, string, ...interface{}) {
+	panic("implement me")
+}
+
+func (m *mockLogger) Name() string {
+	panic("implement me")
+}
+
+func (m *mockLogger) String() string {
+	panic("implement me")
+}
--- a/kgo.go
+++ b/kgo.go
@@ -74,7 +74,7 @@ type Broker struct {

 	opts broker.Options

-	sync.RWMutex
+	mu   sync.RWMutex
 	init bool
 }

@@ -108,7 +108,7 @@ type kgoMessage struct {
 	ctx   context.Context
 	body  []byte
 	hdr   metadata.Metadata
-	opts  broker.PublishOptions
+	opts  broker.MessageOptions
 	ack   bool
 }

@@ -141,18 +141,22 @@ func (b *Broker) newCodec(ct string) (codec.Codec, error) {
 	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
 		ct = ct[:idx]
 	}
-	b.RLock()
+	b.mu.RLock()
 	c, ok := b.opts.Codecs[ct]
-	b.RUnlock()
+	b.mu.RUnlock()
 	if ok {
 		return c, nil
 	}
 	return nil, codec.ErrUnknownContentType
 }

-func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...broker.PublishOption) (broker.Message, error) {
-	options := broker.NewPublishOptions(opts...)
-	m := &kgoMessage{ctx: ctx, hdr: hdr, opts: options}
+func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...broker.MessageOption) (broker.Message, error) {
+	options := broker.NewMessageOptions(opts...)
+	if options.ContentType == "" {
+		options.ContentType = b.opts.ContentType
+	}
+
+	m := &kgoMessage{ctx: ctx, hdr: hdr.Copy(), opts: options}
 	c, err := b.newCodec(m.opts.ContentType)
 	if err == nil {
 		m.body, err = c.Marshal(body)
@@ -161,6 +165,8 @@ func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body int
 		return nil, err
 	}

+	m.hdr.Set(metadata.HeaderContentType, m.opts.ContentType)
+
 	return m, nil
 }

@@ -234,10 +240,10 @@ func (k *Broker) Connect(ctx context.Context) error {
 		return err
 	}

-	k.Lock()
+	k.mu.Lock()
 	k.c = c
 	k.connected.Store(1)
-	k.Unlock()
+	k.mu.Unlock()

 	return nil
 }
@@ -255,8 +261,8 @@ func (k *Broker) Disconnect(ctx context.Context) error {
 	ctx, span = k.opts.Tracer.Start(ctx, "Disconnect")
 	defer span.Finish()

-	k.Lock()
-	defer k.Unlock()
+	k.mu.Lock()
+	defer k.mu.Unlock()
 	select {
 	case <-nctx.Done():
 		return nctx.Err()
@@ -280,8 +286,8 @@ func (k *Broker) Disconnect(ctx context.Context) error {
 }

 func (k *Broker) Init(opts ...broker.Option) error {
-	k.Lock()
-	defer k.Unlock()
+	k.mu.Lock()
+	defer k.mu.Unlock()

 	if len(opts) == 0 && k.init {
 		return nil
@@ -340,51 +346,44 @@ func (b *Broker) fnPublish(ctx context.Context, topic string, messages ...broker
 }

 func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.Message) error {
-	if b.connected.Load() == 0 {
-		c, _, err := b.connect(ctx, b.kopts...)
-		if err != nil {
-			return err
-		}
-		b.Lock()
-		b.c = c
-		b.Unlock()
-	}
-
-	records := make([]*kgo.Record, 0, len(messages))
-	var errs []string
-	var key []byte
-	var promise func(*kgo.Record, error)
+	var records []*kgo.Record

 	for _, msg := range messages {

-		if mctx := msg.Context(); mctx != nil {
-			if k, ok := mctx.Value(publishKey{}).([]byte); ok && k != nil {
-				key = k
-			}
-			if p, ok := mctx.Value(publishPromiseKey{}).(func(*kgo.Record, error)); ok && p != nil {
-				promise = p
-			}
-		}
-
 		rec := &kgo.Record{
-			Context: ctx,
-			Key:     key,
+			Context: msg.Context(),
 			Topic:   topic,
 			Value:   msg.Body(),
 		}

-		b.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", rec.Topic, "topic", rec.Topic).Inc()
+		var promise func(*kgo.Record, error)
+		if rec.Context != nil {
+			if k, ok := rec.Context.Value(messageKey{}).([]byte); ok && k != nil {
+				rec.Key = k
+			}
+			if p, ok := rec.Context.Value(messagePromiseKey{}).(func(*kgo.Record, error)); ok && p != nil {
+				promise = p
+			}
+		}
+
+		kmsg, ok := msg.(*kgoMessage)
+		if !ok {
+			continue
+		}
+		if kmsg.opts.Context != nil {
+			if k, ok := kmsg.opts.Context.Value(messageKey{}).([]byte); ok && k != nil {
+				rec.Key = k
+			}
+			if p, ok := kmsg.opts.Context.Value(messagePromiseKey{}).(func(*kgo.Record, error)); ok && p != nil {
+				promise = p
+			}
+		}

 		setHeaders(rec, msg.Header())

-		records = append(records, rec)
-	}
-
-	ts := time.Now()
-
 		if promise != nil {
-
-		for _, rec := range records {
+			ts := time.Now()
+			b.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", rec.Topic, "topic", rec.Topic).Inc()
 			b.c.Produce(ctx, rec, func(r *kgo.Record, err error) {
 				te := time.Since(ts)
 				b.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", rec.Topic, "topic", rec.Topic).Dec()
@@ -397,12 +396,17 @@ func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.M
 				}
 				promise(r, err)
 			})
+			continue
+		} else {
+			records = append(records, rec)
 		}
-		return nil
 	}

+	if len(records) > 0 {
+		var errs []string
+		ts := time.Now()
+		b.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", topic, "topic", topic).Set(uint64(len(records)))
 		results := b.c.ProduceSync(ctx, records...)
-
 		te := time.Since(ts)
 		for _, result := range results {
 			b.opts.Meter.Summary(semconv.PublishMessageLatencyMicroseconds, "endpoint", result.Record.Topic, "topic", result.Record.Topic).Update(te.Seconds())
@@ -419,6 +423,7 @@ func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.M
 		if len(errs) > 0 {
 			return fmt.Errorf("publish error: %s", strings.Join(errs, "\n"))
 		}
+	}

 	return nil
 }
@@ -474,11 +479,15 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac
 		}
 	}

+	var messagePool bool
 	var fatalOnError bool
 	if b.opts.Context != nil {
 		if v, ok := b.opts.Context.Value(fatalOnErrorKey{}).(bool); ok && v {
 			fatalOnError = v
 		}
+		if v, ok := b.opts.Context.Value(subscribeMessagePoolKey{}).(bool); ok && v {
+			messagePool = v
+		}
 	}

 	if options.Context != nil {
@@ -496,6 +505,7 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac
 		done:         make(chan struct{}),
 		fatalOnError: fatalOnError,
 		connected:    b.connected,
+		messagePool:  messagePool,
 	}

 	kopts := append(b.kopts,
@@ -540,9 +550,9 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac

 	go sub.poll(ctx)

-	b.Lock()
+	b.mu.Lock()
 	b.subs = append(b.subs, sub)
-	b.Unlock()
+	b.mu.Unlock()

 	return sub, nil
 }
--- a/kgo_test.go
+++ b/kgo_test.go
@@ -2,15 +2,15 @@ package kgo_test

 import (
 	"context"
-	"os"
-	"strings"
 	"sync/atomic"
 	"testing"
 	"time"

+	"github.com/twmb/franz-go/pkg/kfake"
 	kg "github.com/twmb/franz-go/pkg/kgo"
 	kgo "go.unistack.org/micro-broker-kgo/v4"
 	"go.unistack.org/micro/v4/broker"
+	"go.unistack.org/micro/v4/codec"
 	"go.unistack.org/micro/v4/logger"
 	"go.unistack.org/micro/v4/logger/slog"
 	"go.unistack.org/micro/v4/metadata"
@@ -20,31 +20,33 @@ var (
 	msgcnt   = int64(1200)
 	group    = "38"
 	prefill  = true
-	loglevel = logger.DebugLevel
+	loglevel = logger.ErrorLevel
+	cluster  *kfake.Cluster
 )

-func TestFail(t *testing.T) {
-	if tr := os.Getenv("INTEGRATION_TESTS"); len(tr) > 0 {
-		t.Skip()
-	}
+func TestMain(m *testing.M) {
+	cluster = kfake.MustCluster(
+		kfake.AllowAutoTopicCreation(),
+	)
+	defer cluster.Close()
+	m.Run()
+}

+func TestFail(t *testing.T) {
 	logger.DefaultLogger = slog.NewLogger()
 	if err := logger.DefaultLogger.Init(logger.WithLevel(loglevel)); err != nil {
 		t.Fatal(err)
 	}
 	ctx := context.Background()

-	var addrs []string
-	if addr := os.Getenv("BROKER_ADDRS"); len(addr) == 0 {
-		addrs = []string{"127.0.0.1:9092"}
-	} else {
-		addrs = strings.Split(addr, ",")
-	}
-
 	b := kgo.NewBroker(
-		broker.Addrs(addrs...),
+		broker.ContentType("application/octet-stream"),
+		broker.Codec("application/octet-stream", codec.NewCodec()),
+		broker.Addrs(cluster.ListenAddrs()...),
 		kgo.CommitInterval(5*time.Second),
-		kgo.Options(kg.ClientID("test"), kg.FetchMaxBytes(10*1024*1024),
+		kgo.Options(
+			kg.ClientID("test"),
+			kg.FetchMaxBytes(10*1024*1024),
 			kg.AllowAutoTopicCreation(),
 		),
 	)
@@ -69,33 +71,39 @@ func TestFail(t *testing.T) {
 	t.Logf("broker health %v", b.Health())
 	msgs := make([]broker.Message, 0, msgcnt)
 	for i := int64(0); i < msgcnt; i++ {
-		m, _ := b.NewMessage(ctx, metadata.Pairs("hkey", "hval"), []byte(`test`))
+		m, err := b.NewMessage(ctx, metadata.Pairs("hkey", "hval"), []byte(`test`))
+		if err != nil {
+			t.Fatal(err)
+		}
 		msgs = append(msgs, m)
 	}

+	go func() {
 		for _, msg := range msgs {
-		t.Logf("broker publish")
-		if err := b.Publish(ctx, "test", msg); err != nil {
+			//		t.Logf("broker publish")
+			if err := b.Publish(ctx, "test.fail", msg); err != nil {
 				t.Fatal(err)
 			}
 		}
+	}()
 	//	t.Skip()

 	idx := int64(0)
 	fn := func(msg broker.Message) error {
 		atomic.AddInt64(&idx, 1)
-		time.Sleep(500 * time.Millisecond)
-		t.Logf("ack")
+		time.Sleep(100 * time.Millisecond)
+		// t.Logf("ack")
 		return msg.Ack()
 	}

-	sub, err := b.Subscribe(ctx, "test", fn,
+	sub, err := b.Subscribe(ctx, "test.fail", fn,
 		broker.SubscribeAutoAck(true),
 		broker.SubscribeGroup(group),
 		broker.SubscribeBodyOnly(true))
 	if err != nil {
 		t.Fatal(err)
 	}
+
 	defer func() {
 		if err := sub.Unsubscribe(ctx); err != nil {
 			t.Fatal(err)
@@ -108,17 +116,26 @@ func TestFail(t *testing.T) {
 			t.Logf("health works")
 			break
 		}
-		time.Sleep(1 * time.Second)
+		t.Logf("health sleep")
+		time.Sleep(100 * time.Millisecond)
+		if err := b.Disconnect(ctx); err != nil {
+			t.Fatal(err)
+		}
 	}
 }

 func TestConnect(t *testing.T) {
-	var addrs []string
 	ctx := context.TODO()
 	b := kgo.NewBroker(
-		broker.Addrs(addrs...),
+		broker.ContentType("application/octet-stream"),
+		broker.Codec("application/octet-stream", codec.NewCodec()),
+		broker.Addrs(cluster.ListenAddrs()...),
 		kgo.CommitInterval(5*time.Second),
-		kgo.Options(kg.ClientID("test"), kg.FetchMaxBytes(10*1024*1024)),
+		kgo.Options(
+			kg.ClientID("test"),
+			kg.FetchMaxBytes(10*1024*1024),
+			kg.AllowAutoTopicCreation(),
+		),
 	)
 	if err := b.Init(); err != nil {
 		t.Fatal(err)
@@ -130,26 +147,21 @@ func TestConnect(t *testing.T) {
 }

 func TestPubSub(t *testing.T) {
-	if tr := os.Getenv("INTEGRATION_TESTS"); len(tr) > 0 {
-		t.Skip()
-	}
-
 	if err := logger.DefaultLogger.Init(logger.WithLevel(loglevel)); err != nil {
 		t.Fatal(err)
 	}
 	ctx := context.Background()

-	var addrs []string
-	if addr := os.Getenv("BROKER_ADDRS"); len(addr) == 0 {
-		addrs = []string{"127.0.0.1:29091", "127.0.0.2:29092", "127.0.0.3:29093"}
-	} else {
-		addrs = strings.Split(addr, ",")
-	}
-
 	b := kgo.NewBroker(
-		broker.Addrs(addrs...),
+		broker.ContentType("application/octet-stream"),
+		broker.Codec("application/octet-stream", codec.NewCodec()),
+		broker.Addrs(cluster.ListenAddrs()...),
 		kgo.CommitInterval(5*time.Second),
-		kgo.Options(kg.ClientID("test"), kg.FetchMaxBytes(10*1024*1024)),
+		kgo.Options(
+			kg.ClientID("test"),
+			kg.FetchMaxBytes(10*1024*1024),
+			kg.AllowAutoTopicCreation(),
+		),
 	)

 	if err := b.Init(); err != nil {
@@ -172,7 +184,7 @@ func TestPubSub(t *testing.T) {
 			msgs = append(msgs, m)
 		}

-		if err := b.Publish(ctx, "test", msgs...); err != nil {
+		if err := b.Publish(ctx, "test.pubsub", msgs...); err != nil {
 			t.Fatal(err)
 		}
 		//	t.Skip()
@@ -185,7 +197,7 @@ func TestPubSub(t *testing.T) {
 		return msg.Ack()
 	}

-	sub, err := b.Subscribe(ctx, "test", fn,
+	sub, err := b.Subscribe(ctx, "test.pubsub", fn,
 		broker.SubscribeAutoAck(true),
 		broker.SubscribeGroup(group),
 		broker.SubscribeBodyOnly(true))
@@ -210,7 +222,7 @@ func TestPubSub(t *testing.T) {
 				if prc := atomic.LoadInt64(&idx); prc == msgcnt {
 					close(done)
 				} else {
-					t.Logf("processed %v\n", prc)
+					t.Logf("processed %v of %v\n", prc, msgcnt)
 				}
 			case <-ticker.C:
 				close(done)
--- a/options.go
+++ b/options.go
@@ -27,11 +27,11 @@ func SubscribeContext(ctx context.Context) broker.SubscribeOption {
 	return broker.SetSubscribeOption(subscribeContextKey{}, ctx)
 }

-type publishKey struct{}
+type messageKey struct{}

-// PublishKey set the kafka message key (broker option)
-func PublishKey(key []byte) broker.PublishOption {
-	return broker.SetPublishOption(publishKey{}, key)
+// MessageKey set the kafka message key (broker option)
+func MessageKey(key []byte) broker.MessageOption {
+	return broker.SetMessageOption(messageKey{}, key)
 }

 type optionsKey struct{}
@@ -103,9 +103,16 @@ func SubscribeFatalOnError(b bool) broker.SubscribeOption {
 	return broker.SetSubscribeOption(fatalOnErrorKey{}, b)
 }

-type publishPromiseKey struct{}
+type messagePromiseKey struct{}

-// PublishPromise set the kafka promise func for Produce
-func PublishPromise(fn func(*kgo.Record, error)) broker.PublishOption {
-	return broker.SetPublishOption(publishPromiseKey{}, fn)
+// MessagePromise set the kafka promise func for Produce
+func MessagePromise(fn func(*kgo.Record, error)) broker.MessageOption {
+	return broker.SetMessageOption(messagePromiseKey{}, fn)
+}
+
+type subscribeMessagePoolKey struct{}
+
+// SubscribeMessagePool optionaly enabled/disable message pool
+func SubscribeMessagePool(b bool) broker.SubscribeOption {
+	return broker.SetSubscribeOption(subscribeMessagePoolKey{}, b)
 }
--- a/subscriber.go
+++ b/subscriber.go
@@ -35,6 +35,7 @@ type consumer struct {
 	opts        broker.SubscribeOptions
 	handler     interface{}
 	connected   *atomic.Uint32
+	messagePool bool
 }

 type Subscriber struct {
@@ -42,14 +43,13 @@ type Subscriber struct {
 	c            *kgo.Client
 	htracer      *hookTracer
 	topic        string
-
+	messagePool  bool
 	handler      interface{}
 	done         chan struct{}
 	kopts        broker.Options
 	opts         broker.SubscribeOptions
-
 	connected    *atomic.Uint32
-	sync.RWMutex
+	mu           sync.RWMutex
 	closed       bool
 	fatalOnError bool
 }
@@ -117,11 +117,11 @@ func (s *Subscriber) poll(ctx context.Context) {
 					continue
 				}

-				s.Lock()
+				s.mu.Lock()
 				for p, l := range lmap {
 					s.kopts.Meter.Counter(semconv.BrokerGroupLag, "topic", s.topic, "group", s.opts.Group, "partition", strconv.Itoa(int(p))).Set(uint64(l.Lag))
 				}
-				s.Unlock()
+				s.mu.Unlock()

 			}
 		}
@@ -146,7 +146,12 @@ func (s *Subscriber) poll(ctx context.Context) {

 			fetches.EachPartition(func(p kgo.FetchTopicPartition) {
 				tps := tp{p.Topic, p.Partition}
-				s.consumers[tps].recs <- p
+				s.mu.Lock()
+				c := s.consumers[tps]
+				s.mu.Unlock()
+				if c != nil {
+					c.recs <- p
+				}
 			})
 			s.c.AllowRebalance()
 		}
@@ -160,11 +165,15 @@ func (s *Subscriber) killConsumers(ctx context.Context, lost map[string][]int32)
 	for topic, partitions := range lost {
 		for _, partition := range partitions {
 			tps := tp{topic, partition}
+			s.mu.Lock()
 			pc, ok := s.consumers[tps]
+			s.mu.Unlock()
 			if !ok {
 				continue
 			}
+			s.mu.Lock()
 			delete(s.consumers, tps)
+			s.mu.Unlock()
 			close(pc.quit)
 			if s.kopts.Logger.V(logger.DebugLevel) {
 				s.kopts.Logger.Debug(ctx, fmt.Sprintf("[kgo] waiting for work to finish topic %s partition %d", topic, partition))
@@ -177,7 +186,7 @@ func (s *Subscriber) killConsumers(ctx context.Context, lost map[string][]int32)

 func (s *Subscriber) autocommit(_ *kgo.Client, _ *kmsg.OffsetCommitRequest, _ *kmsg.OffsetCommitResponse, err error) {
 	if err != nil {
-		s.connected.Store(0)
+		//		s.connected.Store(0)
 		if s.fatalOnError {
 			s.kopts.Logger.Fatal(context.TODO(), "kgo.AutoCommitCallback error", err)
 		}
@@ -215,13 +224,14 @@ func (s *Subscriber) assigned(_ context.Context, c *kgo.Client, assigned map[str
 				done:        make(chan struct{}),
 				recs:        make(chan kgo.FetchTopicPartition, 100),
 				handler:     s.handler,
+				messagePool: s.messagePool,
 				kopts:       s.kopts,
 				opts:        s.opts,
 				connected:   s.connected,
 			}
-			s.Lock()
+			s.mu.Lock()
 			s.consumers[tp{topic, partition}] = pc
-			s.Unlock()
+			s.mu.Unlock()
 			go pc.consume()
 		}
 	}
@@ -236,6 +246,8 @@ func (pc *consumer) consume() {
 		defer pc.kopts.Logger.Debug(pc.kopts.Context, fmt.Sprintf("killing, topic %s partition %d", pc.topic, pc.partition))
 	}

+	var pm *kgoMessage
+
 	for {
 		select {
 		case <-pc.quit:
@@ -245,50 +257,64 @@ func (pc *consumer) consume() {
 				ctx, sp := pc.htracer.WithProcessSpan(record)
 				ts := time.Now()
 				pc.kopts.Meter.Counter(semconv.SubscribeMessageInflight, "endpoint", record.Topic, "topic", record.Topic).Inc()
-				p := messagePool.Get().(*kgoMessage)

-				p.body = record.Value
-				p.topic = record.Topic
-				p.ack = false
-				p.hdr = metadata.New(len(record.Headers))
-				p.ctx = ctx
-				for _, hdr := range record.Headers {
-					p.hdr.Set(hdr.Key, string(hdr.Value))
+				if pc.messagePool {
+					pm = messagePool.Get().(*kgoMessage)
+				} else {
+					pm = &kgoMessage{}
 				}
-
+				pm.body = record.Value
+				pm.topic = record.Topic
+				pm.ack = false
+				pm.hdr = metadata.New(len(record.Headers))
+				pm.ctx = ctx
+				for _, hdr := range record.Headers {
+					pm.hdr.Set(hdr.Key, string(hdr.Value))
+				}
+				pm.hdr.Set("Micro-Offset", strconv.FormatInt(record.Offset, 10))
+				pm.hdr.Set("Micro-Partition", strconv.FormatInt(int64(record.Partition), 10))
+				pm.hdr.Set("Micro-Topic", record.Topic)
+				pm.hdr.Set("Micro-Key", string(record.Key))
+				pm.hdr.Set("Micro-Timestamp", strconv.FormatInt(record.Timestamp.Unix(), 10))
 				switch h := pc.handler.(type) {
 				case func(broker.Message) error:
-					err = h(p)
+					err = h(pm)
 				case func([]broker.Message) error:
-					err = h([]broker.Message{p})
+					err = h([]broker.Message{pm})
 				}

 				pc.kopts.Meter.Counter(semconv.SubscribeMessageInflight, "endpoint", record.Topic, "topic", record.Topic).Dec()
 				if err != nil {
+					if sp != nil {
 						sp.SetStatus(tracer.SpanStatusError, err.Error())
+					}
 					pc.kopts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", record.Topic, "topic", record.Topic, "status", "failure").Inc()
 				} else if pc.opts.AutoAck {
-					p.ack = true
+					pm.ack = true
 				}

 				te := time.Since(ts)
 				pc.kopts.Meter.Summary(semconv.SubscribeMessageLatencyMicroseconds, "endpoint", record.Topic, "topic", record.Topic).Update(te.Seconds())
 				pc.kopts.Meter.Histogram(semconv.SubscribeMessageDurationSeconds, "endpoint", record.Topic, "topic", record.Topic).Update(te.Seconds())

-				ack := p.ack
+				ack := pm.ack
+				if pc.messagePool {
 					messagePool.Put(p)
-
+				}
 				if ack {
 					pc.c.MarkCommitRecords(record)
 				} else {
+					if sp != nil {
 						sp.Finish()
-					pc.connected.Store(0)
+					}
+					//					pc.connected.Store(0)
 					pc.kopts.Logger.Fatal(pc.kopts.Context, "[kgo] message not commited")
 					return
 				}
-
+				if sp != nil {
 					sp.Finish()
 				}
 			}
 		}
+	}
 }
--- a/tracer.go
+++ b/tracer.go
@@ -32,6 +32,9 @@ var (
 // the record's context, so it can be ended in the OnProduceRecordUnbuffered
 // hook.
 func (m *hookTracer) OnProduceRecordBuffered(r *kgo.Record) {
+	if !m.tracer.Enabled() {
+		return
+	}
 	// Set up span options.
 	attrs := []interface{}{
 		messagingSystem,
@@ -77,6 +80,9 @@ func (m *hookTracer) OnProduceRecordBuffered(r *kgo.Record) {
 // It sets attributes with values unset when producing and records any error
 // that occurred during the publish operation.
 func (m *hookTracer) OnProduceRecordUnbuffered(r *kgo.Record, err error) {
+	if !m.tracer.Enabled() {
+		return
+	}
 	if span, ok := tracer.SpanFromContext(r.Context); ok {
 		span.AddLabels(
 			semconv.MessagingKafkaDestinationPartition(int(r.Partition)),
@@ -96,6 +102,9 @@ func (m *hookTracer) OnProduceRecordUnbuffered(r *kgo.Record, err error) {
 // OnFetchRecordUnbuffered hook and can be used in downstream consumer
 // processing.
 func (m *hookTracer) OnFetchRecordBuffered(r *kgo.Record) {
+	if !m.tracer.Enabled() {
+		return
+	}
 	// Set up the span options.
 	attrs := []interface{}{
 		messagingSystem,
@@ -141,6 +150,9 @@ func (m *hookTracer) OnFetchRecordBuffered(r *kgo.Record) {
 // OnFetchRecordUnbuffered continues and ends the "receive" span for an
 // unbuffered record.
 func (m *hookTracer) OnFetchRecordUnbuffered(r *kgo.Record, _ bool) {
+	if !m.tracer.Enabled() {
+		return
+	}
 	span, _ := tracer.SpanFromContext(r.Context)
 	span.Finish()
 }
@@ -155,6 +167,13 @@ func (m *hookTracer) OnFetchRecordUnbuffered(r *kgo.Record, _ bool) {
 // not a record which has been created for producing, so call this at the start of each
 // iteration of your processing for the record.
 func (m *hookTracer) WithProcessSpan(r *kgo.Record) (context.Context, tracer.Span) {
+	if r.Context == nil {
+		r.Context = context.Background()
+	}
+
+	if !m.tracer.Enabled() {
+		return r.Context, nil
+	}
 	// Set up the span options.
 	attrs := []interface{}{
 		messagingSystem,
Author	SHA1	Message	Date
Vasiliy Tolstov	63d82be92a	add additional metadata to message, closes #194 Some checks failed sync / sync (push) Failing after 12m3s Details coverage / build (push) Failing after 13m41s Details test / test (push) Successful in 4m0s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-07-15 15:59:05 +03:00
pugnack	cced3b84c1	remove noisy logs from event hooks and add tests (#193 ) Some checks failed coverage / build (push) Failing after 1m50s Details test / test (push) Failing after 19m17s Details sync / sync (push) Successful in 7s Details	2025-07-10 12:51:26 +03:00
vtolstov	82c1bda50f	Apply Code Coverage Badge	2025-07-02 13:21:33 +00:00
Vasiliy Tolstov	4b0b70e7d0	fixup message options and content-type header Some checks failed coverage / build (push) Successful in 4m34s Details test / test (push) Failing after 17m28s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-07-02 16:20:02 +03:00
vtolstov	da88718e03	Apply Code Coverage Badge	2025-06-30 13:11:01 +00:00
Vasiliy Tolstov	aed304b7e3	rework message options Some checks failed sync / sync (push) Successful in 1m2s Details coverage / build (push) Successful in 3m31s Details test / test (push) Failing after 18m28s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-06-30 16:08:59 +03:00
pugnack	b796c43257	[v4] hide access to internal mutex (#185 ) Some checks failed coverage / build (push) Failing after 2m4s Details test / test (push) Successful in 3m53s Details sync / sync (push) Successful in 8s Details * changed embedded mutex to private field * update ci * fix tests	2025-06-10 16:28:17 +03:00
Vasiliy Tolstov	b0691edf82	disable message pool by default Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-06-10 16:28:16 +03:00
Vasiliy Tolstov	d43b59f2f3	disable message pool by default Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-06-10 16:28:03 +03:00
Vasiliy Tolstov	f976516d6b	new kgo version update deps fixup race conditions add kfake usage Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-06-10 16:27:40 +03:00
pugnack	8f5c03ad60	[v4] hide access to internal mutex (#185 ) * changed embedded mutex to private field * update ci * fix tests	2025-06-10 16:26:52 +03:00
vtolstov	9e9c1434ff	Apply Code Coverage Badge	2025-06-09 14:30:14 +00:00
Vasiliy Tolstov	fe81a14413	update for latest micro Some checks failed coverage / build (push) Successful in 3m22s Details test / test (push) Failing after 19m17s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-06-09 17:27:45 +03:00
Vasiliy Tolstov	eb56a48dda	update kgo Some checks failed coverage / build (push) Has been cancelled Details test / test (push) Has been cancelled Details sync / sync (push) Failing after 28s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-25 01:25:56 +03:00
Vasiliy Tolstov	71e8a13c70	new kgo version Some checks failed sync / sync (push) Has been cancelled Details coverage / build (push) Failing after 1m31s Details test / test (push) Failing after 18m29s Details update deps fixup race conditions add kfake usage Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-25 01:24:50 +03:00
pugnack	b538ef82b5	[v4] hide access to internal mutex (#185 ) * changed embedded mutex to private field * update ci * fix tests	2025-05-25 01:23:46 +03:00
pugnack	44e2d5f9a4	update ci (#188 )	2025-05-25 01:23:11 +03:00
vtolstov	9426208e1c	Apply Code Coverage Badge	2025-05-21 08:14:38 +00:00
Vasiliy Tolstov	d6e73a3419	minimize checks on publish Some checks failed coverage / build (push) Successful in 4m51s Details sync / sync (push) Has been skipped Details test / test (push) Failing after 15m31s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-21 09:54:16 +03:00
Vasiliy Tolstov	969e459e3d	add tracer enabled status Some checks failed test / test (push) Failing after 17m28s Details coverage / build (push) Failing after 17m37s Details sync / sync (push) Has been cancelled Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-19 09:34:24 +03:00
vtolstov	b2cd7d8b8e	Apply Code Coverage Badge	2025-05-18 16:02:55 +00:00
Vasiliy Tolstov	6d85d3ee41	disable message pool by default Some checks failed sync / sync (push) Has been skipped Details test / test (push) Successful in 4m47s Details coverage / build (push) Failing after 18m8s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-18 18:58:57 +03:00
Василий Толстов	d0978fb314	Обновить README.md Some checks failed coverage / build (push) Failing after 18m14s Details test / test (push) Successful in 3m43s Details sync / sync (push) Has been skipped Details	2025-05-12 11:05:30 +03:00
vtolstov	0bd81d1253	Apply Code Coverage Badge	2025-05-10 22:53:42 +00:00
Vasiliy Tolstov	e34f57a515	new kgo version All checks were successful sync / sync (push) Has been skipped Details coverage / build (push) Successful in 4m56s Details test / test (push) Successful in 4m59s Details update deps fixup race conditions add kfake usage Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-11 01:49:38 +03:00
Vasiliy Tolstov	ccd912adb2	dont modify connected state on errors Some checks failed coverage / build (push) Failing after 1m1s Details test / test (push) Successful in 5m12s Details sync / sync (push) Has been skipped Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-05-02 19:08:54 +03:00
Vasiliy Tolstov	db97b24904	improve sync All checks were successful sync / sync (push) Successful in 47s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-04-27 21:02:58 +03:00
Vasiliy Tolstov	7410408fc4	update deps Some checks failed coverage / build (push) Failing after 1m8s Details test / test (push) Successful in 3m27s Details sync / sync (push) Successful in 10s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-04-27 16:12:32 +03:00
Vasiliy Tolstov	4d28a6ebb2	update actions Some checks failed coverage / build (push) Failing after 1m24s Details sync / sync (push) Successful in 13s Details test / test (push) Successful in 2m8s Details Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>	2025-04-27 16:09:17 +03:00