From 1cc6093bdd8c0b052949f3dd94af97e27e5fdaa9 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Thu, 20 Mar 2025 18:23:39 +0000
Subject: [PATCH 01/15] stash

---
 src/brod.erl               | 32 +++++++++++++++++++++++++++++
 src/brod_client.erl        | 41 ++++++++++++++++++++++++++++++++++++++
 src/brod_kafka_apis.erl    | 33 +++++++++++++++---------------
 src/brod_kafka_request.erl | 12 +++++++++++
 src/brod_utils.erl         | 24 ++++++++++++++++++++++
 5 files changed, 126 insertions(+), 16 deletions(-)

diff --git a/src/brod.erl b/src/brod.erl
index 415ad28c..a285b769 100644
--- a/src/brod.erl
+++ b/src/brod.erl
@@ -96,6 +96,8 @@
 %% Topic APIs
 -export([ create_topics/3
         , create_topics/4
+        , create_partitions/3
+        , create_partitions/4
         , delete_topics/3
         , delete_topics/4
         ]).
@@ -190,6 +192,7 @@
 -type endpoint() :: {hostname(), portnum()}.
 -type topic() :: kpro:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: kpro:partition().
 -type topic_partition() :: {topic(), partition()}.
 -type offset() :: kpro:offset(). %% Physical offset (an integer)
@@ -1049,6 +1052,35 @@ create_topics(Hosts, TopicConfigs, RequestConfigs) ->
 create_topics(Hosts, TopicConfigs, RequestConfigs, Options) ->
   brod_utils:create_topics(Hosts, TopicConfigs, RequestConfigs, Options).
 
+%% @equiv create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, [])
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()}) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs) ->
+  brod_utils:create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs).
+
+%% @doc Create partitions(s) in kafka.
+%% See {@link create_topics/4} for more information.
+%%
+%% Example:
+%% ```
+%% > TopicPartitionConfigs = [
+%%       #{
+%%         topic: <<"my_topic">>,
+%%          new_partitions: #{
+%%            count: 6,
+%%            assignment: [[1,2], [2,3], [3,1]]
+%%        }
+%%      }
+%%   ].
+%% > brod:create_partitions([{"localhost", 9092}], TopicPartitionConfigs, #{timeout => 1000}, []).
+%% ok
+%% '''
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()},
+                    conn_config()) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, Options) ->
+  brod_utils:create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, Options).
+
 %% @equiv delete_topics(Hosts, Topics, Timeout, [])
 -spec delete_topics([endpoint()], [topic()], pos_integer()) ->
         ok | {error, any()}.
diff --git a/src/brod_client.erl b/src/brod_client.erl
index f624da6c..6536df4b 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -72,6 +72,7 @@
 -define(DEFAULT_RECONNECT_COOL_DOWN_SECONDS, 1).
 -define(DEFAULT_GET_METADATA_TIMEOUT_SECONDS, 5).
 -define(DEFAULT_UNKNOWN_TOPIC_CACHE_TTL, 120000).
+-define(DEFAULT_SYNC_METADATA_INTERVAL_SECONDS, 60).
 
 %% ClientId as ets table name.
 -define(ETS(ClientId), ClientId).
@@ -345,6 +346,7 @@ init({BootstrapEndpoints, ClientId, Config}) ->
   Tab = ets:new(?ETS(ClientId),
                 [named_table, protected, {read_concurrency, true}]),
   self() ! init,
+  maybe_start_metadata_sync(Config),
   {ok, #state{ client_id           = ClientId
              , bootstrap_endpoints = BootstrapEndpoints
              , config              = Config
@@ -362,6 +364,11 @@ handle_info(init, State0) ->
                       , consumers_sup       = ConsumersSupPid
                       },
   {noreply, State};
+handle_info(sync, #state{config = Config, producers_sup = Sup} = State) ->
+  Children = brod_supervisor3:which_children(Sup),
+  NewState = sync_topics_metadata(Children, State),
+  erlang:send_after(sync_interval(Config), self(), sync),
+  {noreply, NewState};
 handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                                          , producers_sup = Pid
                                          } = State) ->
@@ -695,6 +702,11 @@ timeout(Config) ->
              ?DEFAULT_GET_METADATA_TIMEOUT_SECONDS),
   timer:seconds(T).
 
+sync_interval(Config) ->
+  T = config(sync_metadata_interval_seconds, Config,
+             ?DEFAULT_SYNC_METADATA_INTERVAL_SECONDS),
+  timer:seconds(T).
+
 config(Key, Config, Default) ->
   proplists:get_value(Key, Config, Default).
 
@@ -719,6 +731,35 @@ ensure_binary(ClientId) when is_atom(ClientId) ->
 ensure_binary(ClientId) when is_binary(ClientId) ->
   ClientId.
 
+maybe_start_metadata_sync(Config) ->
+  case config(sync_metadata, Config, false) of
+    true ->
+      erlang:send_after(sync_interval(Config), self(), sync),
+      ok;
+    false ->
+      ok
+  end.
+
+sync_topics_metadata(Children, State) ->
+  lists:foldl(fun({Topic, _, _, _}, StateAcc) -> sync_topic_metadata(Topic, StateAcc) end, State, Children).
+
+sync_topic_metadata(Topic, State) ->
+  case do_get_metadata(Topic, State) of
+    {{ok, #{ topics := [ #{ partitions := Partitions } ] }}, NewState} ->
+      lists:foreach(fun (Partition) -> sync_topic_partition(Partition, Topic, State) end, Partitions),
+      NewState;
+    {{error, _}, NewState} ->
+      NewState
+  end.
+
+sync_topic_partition(#{ partition_index := Partition }, Topic, #state{ producers_sup = Sup, client_id = Client, config = Config}) ->
+  case brod_producers_sup:find_producer(Sup, Topic, Partition) of
+    {ok, _} ->
+      ok;
+    {error, {producer_not_found, _, _}} ->
+      brod_producer:start_link(Client, Topic, Partition, Config)
+  end.
+
 -spec maybe_connect(state(), endpoint()) ->
         {Result, state()} when Result :: {ok, pid()} | {error, any()}.
 maybe_connect(#state{} = State, Endpoint) ->
diff --git a/src/brod_kafka_apis.erl b/src/brod_kafka_apis.erl
index 75bbbe6b..282f8b02 100644
--- a/src/brod_kafka_apis.erl
+++ b/src/brod_kafka_apis.erl
@@ -139,22 +139,23 @@ lookup_vsn_range(Conn, API) ->
 %% Do not change range without verification.
 supported_versions(API) ->
   case API of
-    produce          -> {0, 7};
-    fetch            -> {0, 10};
-    list_offsets     -> {0, 2};
-    metadata         -> {0, 2};
-    offset_commit    -> {2, 2};
-    offset_fetch     -> {1, 2};
-    find_coordinator -> {0, 0};
-    join_group       -> {0, 1};
-    heartbeat        -> {0, 0};
-    leave_group      -> {0, 0};
-    sync_group       -> {0, 0};
-    describe_groups  -> {0, 0};
-    list_groups      -> {0, 0};
-    create_topics    -> {0, 0};
-    delete_topics    -> {0, 0};
-    _                -> erlang:error({unsupported_api, API})
+    produce           -> {0, 7};
+    fetch             -> {0, 10};
+    list_offsets      -> {0, 2};
+    metadata          -> {0, 2};
+    offset_commit     -> {2, 2};
+    offset_fetch      -> {1, 2};
+    find_coordinator  -> {0, 0};
+    join_group        -> {0, 1};
+    heartbeat         -> {0, 0};
+    leave_group       -> {0, 0};
+    sync_group        -> {0, 0};
+    describe_groups   -> {0, 0};
+    list_groups       -> {0, 0};
+    create_topics     -> {0, 0};
+    create_partitions -> {0, 1};
+    delete_topics     -> {0, 0};
+    _                 -> erlang:error({unsupported_api, API})
   end.
 
 monitor_connection(Conn) ->
diff --git a/src/brod_kafka_request.erl b/src/brod_kafka_request.erl
index c6046aab..00261278 100644
--- a/src/brod_kafka_request.erl
+++ b/src/brod_kafka_request.erl
@@ -18,6 +18,7 @@
 -module(brod_kafka_request).
 
 -export([ create_topics/3
+        , create_partitions/3
         , delete_topics/3
         , fetch/8
         , list_groups/1
@@ -36,6 +37,7 @@
 -type vsn() :: brod_kafka_apis:vsn().
 -type topic() :: brod:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: brod:partition().
 -type offset() :: brod:offset().
 -type conn() :: kpro:connection().
@@ -65,6 +67,16 @@ create_topics(Connection, TopicConfigs, RequestConfigs)
 create_topics(Vsn, TopicConfigs, RequestConfigs) ->
   kpro_req_lib:create_topics(Vsn, TopicConfigs, RequestConfigs).
 
+%% @doc Make a create_partitions request.
+-spec create_partitions(vsn() | conn(), [topic_partition_config()], #{timeout => kpro:int32(),
+                    validate_only => boolean()}) -> kpro:req().
+create_partitions(Connection, TopicPartitionConfigs, RequestConfigs)
+              when is_pid(Connection) ->
+  Vsn = brod_kafka_apis:pick_version(Connection, create_partitions),
+  create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs);
+create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs) ->
+  kpro_req_lib:create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs).
+
 %% @doc Make a delete_topics request.
 -spec delete_topics(vsn() | conn(), [topic()], pos_integer()) -> kpro:req().
 delete_topics(Connection, Topics, Timeout) when is_pid(Connection) ->
diff --git a/src/brod_utils.erl b/src/brod_utils.erl
index e6525f01..e3c54b9a 100644
--- a/src/brod_utils.erl
+++ b/src/brod_utils.erl
@@ -26,6 +26,8 @@
         , describe_groups/3
         , create_topics/3
         , create_topics/4
+        , create_partitions/3
+        , create_partitions/4
         , delete_topics/3
         , delete_topics/4
         , epoch_ms/0
@@ -73,6 +75,7 @@
 -type conn_config() :: brod:conn_config().
 -type topic() :: brod:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: brod:partition().
 -type offset() :: brod:offset().
 -type endpoint() :: brod:endpoint().
@@ -103,6 +106,27 @@ create_topics(Hosts, TopicConfigs, RequestConfigs, ConnCfg) ->
                   Pid, TopicConfigs, RequestConfigs),
                 request_sync(Pid, Request)
             end).
+
+%% @equiv create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, [])
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()}) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs) ->
+  create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, _ConnCfg = []).
+
+%% @doc Try to connect to the controller node using the given
+%% connection options and create the given partitions with configs
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()},
+                    conn_config()) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, ConnCfg) ->
+  KproOpts = kpro_connection_options(ConnCfg),
+  with_conn(kpro:connect_controller(Hosts, nolink(ConnCfg), KproOpts),
+            fun(Pid) ->
+                Request = brod_kafka_request:create_partitions(
+                  Pid, TopicPartitionConfigs, RequestConfigs),
+                request_sync(Pid, Request)
+            end).
+
 %% @equiv delete_topics(Hosts, Topics, Timeout, [])
 -spec delete_topics([endpoint()], [topic()], pos_integer()) ->
         ok | {error, any()}.

From 2e91370c380a75ddfc4a7b5587f160f984616f41 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Thu, 20 Mar 2025 19:06:02 +0000
Subject: [PATCH 02/15] update inline docs

---
 src/brod.erl | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/brod.erl b/src/brod.erl
index a285b769..d49dba5f 100644
--- a/src/brod.erl
+++ b/src/brod.erl
@@ -1059,7 +1059,16 @@ create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs) ->
   brod_utils:create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs).
 
 %% @doc Create partitions(s) in kafka.
-%% See {@link create_topics/4} for more information.
+%%  <ul>
+%%    <li>`topic'
+%%      The topic name.
+%%    </li>
+%%
+%%    <li>`new_partitions'
+%%      The `count` of how many partitions will exist for the topic. current + desired
+%%      The number of `assignment` should be equal to the number of new partitions.
+%%      Each list for assignment specify the prefferred broker ids to assign
+%%    </li>
 %%
 %% Example:
 %% ```

From 9d808635329759d6fb9a81e6c6cbf711f3024686 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Thu, 20 Mar 2025 20:59:21 +0000
Subject: [PATCH 03/15] add simple tests

---
 src/brod_client.erl        | 15 +++++++++------
 test/brod_SUITE.erl        | 17 +++++++++++++++--
 test/brod_client_SUITE.erl | 28 ++++++++++++++++++++++++++--
 3 files changed, 50 insertions(+), 10 deletions(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index 6536df4b..66182b6c 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -55,6 +55,7 @@
 
 %% Test export
 -export([ lookup_partitions_count_cache/2
+        , sync_topics_metadata/2
         ]).
 
 -export([ code_change/3
@@ -131,6 +132,7 @@
         , consumers_sup        :: ?undef | pid()
         , config               :: ?undef | config()
         , workers_tab          :: ?undef | ets:tab()
+        , sync_ref             :: ?undef | reference()
         }).
 
 -type state() :: #state{}.
@@ -346,11 +348,12 @@ init({BootstrapEndpoints, ClientId, Config}) ->
   Tab = ets:new(?ETS(ClientId),
                 [named_table, protected, {read_concurrency, true}]),
   self() ! init,
-  maybe_start_metadata_sync(Config),
+  SyncRef = maybe_start_metadata_sync(Config),
   {ok, #state{ client_id           = ClientId
              , bootstrap_endpoints = BootstrapEndpoints
              , config              = Config
              , workers_tab         = Tab
+             , sync_ref            = SyncRef
              }}.
 
 %% @private
@@ -366,9 +369,10 @@ handle_info(init, State0) ->
   {noreply, State};
 handle_info(sync, #state{config = Config, producers_sup = Sup} = State) ->
   Children = brod_supervisor3:which_children(Sup),
+  io:format("=========================~P~n", [Children, 1000]),
   NewState = sync_topics_metadata(Children, State),
-  erlang:send_after(sync_interval(Config), self(), sync),
-  {noreply, NewState};
+  Ref = erlang:send_after(sync_interval(Config), self(), sync),
+  {noreply, NewState#state{ sync_ref = Ref }};
 handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                                          , producers_sup = Pid
                                          } = State) ->
@@ -734,10 +738,9 @@ ensure_binary(ClientId) when is_binary(ClientId) ->
 maybe_start_metadata_sync(Config) ->
   case config(sync_metadata, Config, false) of
     true ->
-      erlang:send_after(sync_interval(Config), self(), sync),
-      ok;
+      erlang:send_after(sync_interval(Config), self(), sync);
     false ->
-      ok
+      undefined
   end.
 
 sync_topics_metadata(Children, State) ->
diff --git a/test/brod_SUITE.erl b/test/brod_SUITE.erl
index a7f0bb51..1470bf5e 100644
--- a/test/brod_SUITE.erl
+++ b/test/brod_SUITE.erl
@@ -25,7 +25,7 @@
         ]).
 
 %% Test cases
--export([ t_create_delete_topics/1
+-export([ t_create_update_delete_topics/1
         , t_delete_topics_not_found/1
         ]).
 
@@ -59,7 +59,7 @@ all() -> [F || {F, _A} <- module_info(exports),
 
 %%%_* Test functions ===========================================================
 
-t_create_delete_topics(Config) when is_list(Config) ->
+t_create_update_delete_topics(Config) when is_list(Config) ->
   Topic = iolist_to_binary(["test-topic-", integer_to_list(erlang:system_time())]),
   TopicConfig = [
     #{
@@ -70,9 +70,22 @@ t_create_delete_topics(Config) when is_list(Config) ->
       name => Topic
     }
   ],
+  TopicPartitionConfig = [
+    #{
+      topic => Topic,
+      new_partitions => #{
+        count => 2,
+        assignment => [[0]]
+      }
+    }
+  ],
   try
     ?assertEqual(ok,
       brod:create_topics(?HOSTS, TopicConfig, #{timeout => ?TIMEOUT},
+        #{connect_timeout => ?TIMEOUT})),
+
+    ?assertEqual(ok,
+      brod:create_partitions(?HOSTS, TopicPartitionConfig, #{timeout => ?TIMEOUT},
         #{connect_timeout => ?TIMEOUT}))
   after
     ?assertEqual(ok, brod:delete_topics(?HOSTS, [Topic], ?TIMEOUT,
diff --git a/test/brod_client_SUITE.erl b/test/brod_client_SUITE.erl
index d65b6130..d907b391 100644
--- a/test/brod_client_SUITE.erl
+++ b/test/brod_client_SUITE.erl
@@ -29,7 +29,8 @@
 -export([ auth/6 ]).
 
 %% Test cases
--export([ t_skip_unreachable_endpoint/1
+-export([ t_optional_metadata_syncing/1
+        , t_skip_unreachable_endpoint/1
         , t_no_reachable_endpoint/1
         , t_call_bad_client_id/1
         , t_metadata_connection_restart/1
@@ -69,6 +70,19 @@
           end
         end()).
 
+
+-record(state,
+        { client_id            :: pid()
+        , bootstrap_endpoints  :: [brod:endpoint()]
+        , meta_conn            :: kpro:connection()
+        , payload_conns = []   :: list()
+        , producers_sup        :: pid()
+        , consumers_sup        :: pid()
+        , config               :: list()
+        , workers_tab          :: ets:tab()
+        , sync_ref             :: reference()
+        }).
+
 %%%_* ct callbacks =============================================================
 
 suite() -> [{timetrap, {seconds, 30}}].
@@ -115,6 +129,17 @@ all() ->
 
 %%%_* Test functions ===========================================================
 
+t_optional_metadata_syncing(Config) when is_list(Config) ->
+  Client0 = has_sync,
+  Config0 = [{sync_metadata, true}],
+  {ok, #state{ sync_ref = HasRef }} = brod_client:init({?HOSTS, Client0, Config0}),
+  ?assertNot(HasRef =:= undefined),
+
+  Config1 = [{sync_metadata, false}],
+  Client1 = no_sync,
+  {ok, #state{ sync_ref = NoRef }} = brod_client:init({?HOSTS, Client1, Config1}),
+  ?assertMatch(undefined, NoRef).
+
 t_get_partitions_count_safe(Config) when is_list(Config) ->
   Client = ?FUNCTION_NAME,
   ok = start_client(?HOSTS, Client),
@@ -141,7 +166,6 @@ t_get_partitions_count_configure_cache_ttl(Config) when is_list(Config) ->
   ?assertMatch(false, Res3),
   ok = brod:stop_client(Client).
 
-
 t_skip_unreachable_endpoint(Config) when is_list(Config) ->
   Client = t_skip_unreachable_endpoint,
   ok = start_client([{"localhost", 8192} | ?HOSTS], Client),

From a8a7b579cebf43233c082d4d85ccfbad69efed4e Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Thu, 20 Mar 2025 21:19:11 +0000
Subject: [PATCH 04/15] remove inspect

---
 src/brod_client.erl | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index 66182b6c..9be44188 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -369,7 +369,6 @@ handle_info(init, State0) ->
   {noreply, State};
 handle_info(sync, #state{config = Config, producers_sup = Sup} = State) ->
   Children = brod_supervisor3:which_children(Sup),
-  io:format("=========================~P~n", [Children, 1000]),
   NewState = sync_topics_metadata(Children, State),
   Ref = erlang:send_after(sync_interval(Config), self(), sync),
   {noreply, NewState#state{ sync_ref = Ref }};

From f36e56096244880ea3e2e869c4b3c33edce0935d Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Mon, 24 Mar 2025 16:19:57 +0000
Subject: [PATCH 05/15] separate sync from client

---
 CHANGELOG.md                 |    3 +
 src/brod_client.erl          | 1439 ++++++++++++++++++----------------
 src/brod_partitions_sync.erl |  169 ++++
 src/brod_producers_sup.erl   |  185 +++--
 test/brod_client_SUITE.erl   |   23 +-
 5 files changed, 1059 insertions(+), 760 deletions(-)
 create mode 100644 src/brod_partitions_sync.erl

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e40aad84..6f8910f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Changelog
+- 4.5.0
+  - Expose `create_partitions` from the underlying kafka_protocol
+  - Allow partitions to automatically have producers started for newly discovered partitions.
 
 - 4.4.0
   - Support `zstd` compression.
diff --git a/src/brod_client.erl b/src/brod_client.erl
index 9be44188..9bf76857 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -25,46 +25,47 @@
 -module(brod_client).
 -behaviour(gen_server).
 
--export([ get_consumer/3
-        , get_connection/3
-        , get_group_coordinator/2
-        , get_transactional_coordinator/2
-        , get_leader_connection/3
-        , get_bootstrap/1
-        , get_metadata/2
-        , get_metadata_safe/2
-        , get_partitions_count/2
-        , get_partitions_count_safe/2
-        , get_producer/3
-        , register_consumer/3
-        , register_producer/3
-        , deregister_consumer/3
-        , deregister_producer/3
-        , start_link/3
-        , start_producer/3
-        , start_consumer/3
-        , stop/1
-        , stop_producer/2
-        , stop_consumer/2
-        ]).
+-export([
+    get_consumer/3,
+    get_connection/3,
+    get_group_coordinator/2,
+    get_transactional_coordinator/2,
+    get_leader_connection/3,
+    get_bootstrap/1,
+    get_metadata/2,
+    get_metadata_safe/2,
+    get_partitions_count/2,
+    get_partitions_count_safe/2,
+    get_producer/3,
+    register_consumer/3,
+    register_producer/3,
+    deregister_consumer/3,
+    deregister_producer/3,
+    start_link/3,
+    start_producer/3,
+    start_consumer/3,
+    stop/1,
+    stop_producer/2,
+    stop_consumer/2
+]).
 
 %% Private export
--export([ find_producer/3
-        , find_consumer/3
-        ]).
+-export([
+    find_producer/3,
+    find_consumer/3
+]).
 
 %% Test export
--export([ lookup_partitions_count_cache/2
-        , sync_topics_metadata/2
-        ]).
-
--export([ code_change/3
-        , handle_call/3
-        , handle_cast/2
-        , handle_info/2
-        , init/1
-        , terminate/2
-        ]).
+-export([lookup_partitions_count_cache/2]).
+
+-export([
+    code_change/3,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    init/1,
+    terminate/2
+]).
 
 -export_type([config/0]).
 
@@ -73,20 +74,20 @@
 -define(DEFAULT_RECONNECT_COOL_DOWN_SECONDS, 1).
 -define(DEFAULT_GET_METADATA_TIMEOUT_SECONDS, 5).
 -define(DEFAULT_UNKNOWN_TOPIC_CACHE_TTL, 120000).
--define(DEFAULT_SYNC_METADATA_INTERVAL_SECONDS, 60).
 
 %% ClientId as ets table name.
 -define(ETS(ClientId), ClientId).
 -define(PRODUCER_KEY(Topic, Partition),
-        {producer, Topic, Partition}).
+    {producer, Topic, Partition}
+).
 -define(CONSUMER_KEY(Topic, Partition),
-        {consumer, Topic, Partition}).
+    {consumer, Topic, Partition}
+).
 -define(TOPIC_METADATA_KEY(Topic),
-        {topics, Topic}).
--define(PRODUCER(Topic, Partition, Pid),
-        {?PRODUCER_KEY(Topic, Partition), Pid}).
--define(CONSUMER(Topic, Partition, Pid),
-        {?CONSUMER_KEY(Topic, Partition), Pid}).
+    {topics, Topic}
+).
+-define(PRODUCER(Topic, Partition, Pid), {?PRODUCER_KEY(Topic, Partition), Pid}).
+-define(CONSUMER(Topic, Partition, Pid), {?CONSUMER_KEY(Topic, Partition), Pid}).
 
 -type endpoint() :: brod:endpoint().
 -type client() :: brod:client().
@@ -97,126 +98,132 @@
 -type group_id() :: brod:group_id().
 -type transactional_id() :: brod:transactional_id().
 
--type partition_worker_key() :: ?PRODUCER_KEY(topic(), partition())
-                              | ?CONSUMER_KEY(topic(), partition()).
+-type partition_worker_key() ::
+    ?PRODUCER_KEY(topic(), partition())
+    | ?CONSUMER_KEY(topic(), partition()).
 
--type get_producer_error() :: client_down
-                            | {client_down, any()}
-                            | {producer_down, any()}
-                            | {producer_not_found, topic()}
-                            | {producer_not_found, topic(), partition()}.
+-type get_producer_error() ::
+    client_down
+    | {client_down, any()}
+    | {producer_down, any()}
+    | {producer_not_found, topic()}
+    | {producer_not_found, topic(), partition()}.
 
--type get_consumer_error() :: client_down
-                            | {client_down, any()}
-                            | {consumer_down, any()}
-                            | {consumer_not_found, topic()}
-                            | {consumer_not_found, topic(), partition()}.
+-type get_consumer_error() ::
+    client_down
+    | {client_down, any()}
+    | {consumer_down, any()}
+    | {consumer_not_found, topic()}
+    | {consumer_not_found, topic(), partition()}.
 
--type get_worker_error() :: get_producer_error()
-                          | get_consumer_error().
+-type get_worker_error() ::
+    get_producer_error()
+    | get_consumer_error().
 
 -define(dead_since(TS, REASON), {dead_since, TS, REASON}).
 -type connection() :: kpro:connection().
 -type dead_conn() :: ?dead_since(erlang:timestamp(), any()).
--record(conn,
-       { endpoint :: endpoint()
-       , pid :: connection() | dead_conn()
-       }).
+-record(conn, {
+    endpoint :: endpoint(),
+    pid :: connection() | dead_conn()
+}).
 -type conn_state() :: #conn{}.
--record(state,
-        { client_id            :: client_id()
-        , bootstrap_endpoints  :: [endpoint()]
-        , meta_conn            :: ?undef | connection()
-        , payload_conns = []   :: [conn_state()]
-        , producers_sup        :: ?undef | pid()
-        , consumers_sup        :: ?undef | pid()
-        , config               :: ?undef | config()
-        , workers_tab          :: ?undef | ets:tab()
-        , sync_ref             :: ?undef | reference()
-        }).
+-record(state, {
+    client_id :: client_id(),
+    bootstrap_endpoints :: [endpoint()],
+    meta_conn :: ?undef | connection(),
+    payload_conns = [] :: [conn_state()],
+    producers_sup :: ?undef | pid(),
+    consumers_sup :: ?undef | pid(),
+    config :: ?undef | config(),
+    workers_tab :: ?undef | ets:tab(),
+    partitions_sync :: ?undef | pid()
+}).
 
 -type state() :: #state{}.
 
 %%%_* APIs =====================================================================
 
 -spec start_link([endpoint()], client_id(), config()) ->
-        {ok, pid()} | {error, any()}.
+    {ok, pid()} | {error, any()}.
 start_link(BootstrapEndpoints, ClientId, Config) when is_atom(ClientId) ->
-  Args = {BootstrapEndpoints, ClientId, Config},
-  gen_server:start_link({local, ClientId}, ?MODULE, Args, []).
+    Args = {BootstrapEndpoints, ClientId, Config},
+    gen_server:start_link({local, ClientId}, ?MODULE, Args, []).
 
 -spec stop(client()) -> ok.
 stop(Client) ->
-  Mref = erlang:monitor(process, Client),
-  _ = safe_gen_call(Client, stop, infinity),
-  receive
-    {'DOWN', Mref, process, _, _Reason} ->
-      ok
-  end.
+    Mref = erlang:monitor(process, Client),
+    _ = safe_gen_call(Client, stop, infinity),
+    receive
+        {'DOWN', Mref, process, _, _Reason} ->
+            ok
+    end.
 
 %% @doc Get producer of the given topic-partition.
 %%
 %% The producer is started if auto_start_producers is
 %% enabled in client config.
 -spec get_producer(client(), topic(), partition()) ->
-        {ok, pid()} | {error, get_producer_error()}.
+    {ok, pid()} | {error, get_producer_error()}.
 get_producer(Client, Topic, Partition) ->
-  case get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) of
-    {ok, Pid} ->
-      {ok, Pid};
-    {error, {producer_not_found, Topic}} = Error ->
-      maybe_start_producer(Client, Topic, Partition, Error);
-    Error ->
-      Error
-  end.
+    case get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) of
+        {ok, Pid} ->
+            {ok, Pid};
+        {error, {producer_not_found, Topic}} = Error ->
+            maybe_start_producer(Client, Topic, Partition, Error);
+        Error ->
+            Error
+    end.
 
 %% @doc Get consumer of the given topic-partition.
 -spec get_consumer(client(), topic(), partition()) ->
-        {ok, pid()} | {error, get_consumer_error()}.
+    {ok, pid()} | {error, get_consumer_error()}.
 get_consumer(Client, Topic, Partition) ->
-  get_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)).
+    get_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)).
 
 %% @doc Dynamically start a per-topic producer.
 %%
 %% Return ok if the producer is already started.
 -spec start_producer(client(), topic(), brod:producer_config()) ->
-        ok | {error, any()}.
+    ok | {error, any()}.
 start_producer(Client, TopicName, ProducerConfig) ->
-  case get_producer(Client, TopicName, _Partition = 0) of
-    {ok, _Pid} ->
-      ok; %% already started
-    {error, {producer_not_found, TopicName}} ->
-      Call = {start_producer, TopicName, ProducerConfig},
-      safe_gen_call(Client, Call, infinity);
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    case get_producer(Client, TopicName, _Partition = 0) of
+        {ok, _Pid} ->
+            %% already started
+            ok;
+        {error, {producer_not_found, TopicName}} ->
+            Call = {start_producer, TopicName, ProducerConfig},
+            safe_gen_call(Client, Call, infinity);
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 %% @doc Stop all partition producers of the given topic.
 -spec stop_producer(client(), topic()) -> ok | {error, any()}.
 stop_producer(Client, TopicName) ->
-  safe_gen_call(Client, {stop_producer, TopicName}, infinity).
+    safe_gen_call(Client, {stop_producer, TopicName}, infinity).
 
 %% @doc Dynamically start a topic consumer.
 %%
 %% Returns ok if the consumer is already started.
 -spec start_consumer(client(), topic(), brod:consumer_config()) ->
-                        ok | {error, any()}.
+    ok | {error, any()}.
 start_consumer(Client, TopicName, ConsumerConfig) ->
-  case get_consumer(Client, TopicName, _Partition = 0) of
-    {ok, _Pid} ->
-      ok; %% already started
-    {error, {consumer_not_found, TopicName}} ->
-      Call = {start_consumer, TopicName, ConsumerConfig},
-      safe_gen_call(Client, Call, infinity);
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    case get_consumer(Client, TopicName, _Partition = 0) of
+        {ok, _Pid} ->
+            %% already started
+            ok;
+        {error, {consumer_not_found, TopicName}} ->
+            Call = {start_consumer, TopicName, ConsumerConfig},
+            safe_gen_call(Client, Call, infinity);
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 %% @doc Stop all partition consumers of the given topic.
 -spec stop_consumer(client(), topic()) -> ok | {error, any()}.
 stop_consumer(Client, TopicName) ->
-  safe_gen_call(Client, {stop_consumer, TopicName}, infinity).
+    safe_gen_call(Client, {stop_consumer, TopicName}, infinity).
 
 %% @doc Get the connection to kafka broker which is a leader for given
 %% Topic-Partition.
@@ -226,13 +233,13 @@ stop_consumer(Client, TopicName) ->
 %% If the old connection was dead less than a configurable N seconds ago,
 %% `{error, LastReason}' is returned.
 -spec get_leader_connection(client(), topic(), partition()) ->
-        {ok, pid()} | {error, any()}.
+    {ok, pid()} | {error, any()}.
 get_leader_connection(Client, Topic, Partition) ->
-  safe_gen_call(Client, {get_leader_connection, Topic, Partition}, infinity).
+    safe_gen_call(Client, {get_leader_connection, Topic, Partition}, infinity).
 
 -spec get_bootstrap(client()) -> {ok, brod:bootstrap()} | {error, any()}.
 get_bootstrap(Client) ->
-  safe_gen_call(Client, get_bootstrap, infinity).
+    safe_gen_call(Client, get_bootstrap, infinity).
 
 %% @doc Get connection to a kafka broker.
 %%
@@ -241,62 +248,61 @@ get_bootstrap(Client) ->
 %% If the old connection was dead less than a configurable N seconds ago,
 %% `{error, LastReason}' is returned.
 -spec get_connection(client(), brod:hostname(), brod:portnum()) ->
-        {ok, pid()} | {error, any()}.
+    {ok, pid()} | {error, any()}.
 get_connection(Client, Host, Port) ->
-  safe_gen_call(Client, {get_connection, Host, Port}, infinity).
+    safe_gen_call(Client, {get_connection, Host, Port}, infinity).
 
 %% @doc Get topic metadata, if topic is `undefined', will fetch ALL metadata.
 -spec get_metadata(client(), all | ?undef | topic()) ->
-        {ok, kpro:struct()} | {error, any()}.
+    {ok, kpro:struct()} | {error, any()}.
 get_metadata(Client, ?undef) ->
-  get_metadata(Client, all);
+    get_metadata(Client, all);
 get_metadata(Client, Topic) ->
-  safe_gen_call(Client, {get_metadata, Topic}, infinity).
+    safe_gen_call(Client, {get_metadata, Topic}, infinity).
 
 %% @doc Ensure not topic auto creation even if Kafka has it enabled.
 -spec get_metadata_safe(client(), topic()) ->
-        {ok, kpro:struct()} | {error, any()}.
+    {ok, kpro:struct()} | {error, any()}.
 get_metadata_safe(Client, Topic) ->
-  safe_gen_call(Client, {get_metadata, {_FetchMetadataForTopic = all, Topic}}, infinity).
+    safe_gen_call(Client, {get_metadata, {_FetchMetadataForTopic = all, Topic}}, infinity).
 
 %% @doc Get number of partitions for a given topic.
 -spec get_partitions_count(client(), topic()) -> {ok, pos_integer()} | {error, any()}.
 get_partitions_count(Client, Topic) ->
-  %% Set default allow_topic_auto_creation to true does not imply the topic is always
-  %% auto-created. Kafka can have auto-creation disabled, in which case this option has no effect.
-  get_partitions_count(Client, Topic, #{allow_topic_auto_creation => true}).
+    %% Set default allow_topic_auto_creation to true does not imply the topic is always
+    %% auto-created. Kafka can have auto-creation disabled, in which case this option has no effect.
+    get_partitions_count(Client, Topic, #{allow_topic_auto_creation => true}).
 
 get_partitions_count(Client, Topic, Opts) when is_atom(Client) ->
-  %% Ets =:= ClientId
-  do_get_partitions_count(Client, Client, Topic, Opts);
+    %% Ets =:= ClientId
+    do_get_partitions_count(Client, Client, Topic, Opts);
 get_partitions_count(Client, Topic, Opts) when is_pid(Client) ->
-  case safe_gen_call(Client, get_workers_table, infinity) of
-    {ok, Ets}       -> do_get_partitions_count(Client, Ets, Topic, Opts);
-    {error, Reason} -> {error, Reason}
-  end.
+    case safe_gen_call(Client, get_workers_table, infinity) of
+        {ok, Ets} -> do_get_partitions_count(Client, Ets, Topic, Opts);
+        {error, Reason} -> {error, Reason}
+    end.
 
 %% @doc Get number of partitions for an existing topic.
 %% Ensured not to auto create a topic even when Kafka is configured
 %% with topic auto creation enabled.
 -spec get_partitions_count_safe(client(), topic()) ->
-        {ok, pos_integer()} | {error, any()}.
+    {ok, pos_integer()} | {error, any()}.
 get_partitions_count_safe(Client, Topic) ->
     get_partitions_count(Client, Topic, #{allow_topic_auto_creation => false}).
 
 %% @doc Get broker endpoint and connection config for
 %% connecting a group coordinator.
 -spec get_group_coordinator(client(), group_id()) ->
-        {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
+    {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
 get_group_coordinator(Client, GroupId) ->
-  safe_gen_call(Client, {get_group_coordinator, GroupId}, infinity).
+    safe_gen_call(Client, {get_group_coordinator, GroupId}, infinity).
 
 %% @doc Get broker endpoint and connection config for
 %% connecting a transactional coordinator.
 -spec get_transactional_coordinator(client(), transactional_id()) ->
-        {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
+    {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
 get_transactional_coordinator(Client, TransactionId) ->
-  safe_gen_call(Client, {get_transactional_coordinator, TransactionId}, infinity).
-
+    safe_gen_call(Client, {get_transactional_coordinator, TransactionId}, infinity).
 
 %% @doc Register self() as a partition producer.
 %%
@@ -305,9 +311,9 @@ get_transactional_coordinator(Client, TransactionId) ->
 %% produce requests to the producer process directly.
 -spec register_producer(client(), topic(), partition()) -> ok.
 register_producer(Client, Topic, Partition) ->
-  Producer = self(),
-  Key = ?PRODUCER_KEY(Topic, Partition),
-  gen_server:cast(Client, {register, Key, Producer}).
+    Producer = self(),
+    Key = ?PRODUCER_KEY(Topic, Partition),
+    gen_server:cast(Client, {register, Key, Producer}).
 
 %% @doc De-register the producer for a partition.
 %%
@@ -316,8 +322,8 @@ register_producer(Client, Topic, Partition) ->
 %% stopped producers and allow later restart.
 -spec deregister_producer(client(), topic(), partition()) -> ok.
 deregister_producer(Client, Topic, Partition) ->
-  Key = ?PRODUCER_KEY(Topic, Partition),
-  gen_server:cast(Client, {deregister, Key}).
+    Key = ?PRODUCER_KEY(Topic, Partition),
+    gen_server:cast(Client, {deregister, Key}).
 
 %% @doc Register self() as a partition consumer.
 %%
@@ -326,9 +332,9 @@ deregister_producer(Client, Topic, Partition) ->
 %% calls to the process directly.
 -spec register_consumer(client(), topic(), partition()) -> ok.
 register_consumer(Client, Topic, Partition) ->
-  Consumer = self(),
-  Key = ?CONSUMER_KEY(Topic, Partition),
-  gen_server:cast(Client, {register, Key, Consumer}).
+    Consumer = self(),
+    Key = ?CONSUMER_KEY(Topic, Partition),
+    gen_server:cast(Client, {register, Key, Consumer}).
 
 %% @doc De-register the consumer for a partition.
 %%
@@ -337,263 +343,298 @@ register_consumer(Client, Topic, Partition) ->
 %% allow later restart.
 -spec deregister_consumer(client(), topic(), partition()) -> ok.
 deregister_consumer(Client, Topic, Partition) ->
-  Key = ?CONSUMER_KEY(Topic, Partition),
-  gen_server:cast(Client, {deregister, Key}).
+    Key = ?CONSUMER_KEY(Topic, Partition),
+    gen_server:cast(Client, {deregister, Key}).
 
 %%%_* gen_server callbacks =====================================================
 
 %% @private
 init({BootstrapEndpoints, ClientId, Config}) ->
-  erlang:process_flag(trap_exit, true),
-  Tab = ets:new(?ETS(ClientId),
-                [named_table, protected, {read_concurrency, true}]),
-  self() ! init,
-  SyncRef = maybe_start_metadata_sync(Config),
-  {ok, #state{ client_id           = ClientId
-             , bootstrap_endpoints = BootstrapEndpoints
-             , config              = Config
-             , workers_tab         = Tab
-             , sync_ref            = SyncRef
-             }}.
+    erlang:process_flag(trap_exit, true),
+    Tab = ets:new(
+        ?ETS(ClientId),
+        [named_table, protected, {read_concurrency, true}]
+    ),
+    self() ! init,
+
+    {ok, #state{
+        client_id = ClientId,
+        bootstrap_endpoints = BootstrapEndpoints,
+        config = Config,
+        workers_tab = Tab
+    }}.
 
 %% @private
 handle_info(init, State0) ->
-  Endpoints = State0#state.bootstrap_endpoints,
-  State1 = ensure_metadata_connection(State0),
-  {ok, ProducersSupPid} = brod_producers_sup:start_link(),
-  {ok, ConsumersSupPid} = brod_consumers_sup:start_link(),
-  State = State1#state{ bootstrap_endpoints = Endpoints
-                      , producers_sup       = ProducersSupPid
-                      , consumers_sup       = ConsumersSupPid
-                      },
-  {noreply, State};
-handle_info(sync, #state{config = Config, producers_sup = Sup} = State) ->
-  Children = brod_supervisor3:which_children(Sup),
-  NewState = sync_topics_metadata(Children, State),
-  Ref = erlang:send_after(sync_interval(Config), self(), sync),
-  {noreply, NewState#state{ sync_ref = Ref }};
-handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
-                                         , producers_sup = Pid
-                                         } = State) ->
-  ?BROD_LOG_ERROR("client ~p producers supervisor down~nReason: ~p",
-                  [ClientId, Pid, Reason]),
-  {stop, {producers_sup_down, Reason}, State};
-handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
-                                         , consumers_sup = Pid
-                                         } = State) ->
-  ?BROD_LOG_ERROR("client ~p consumers supervisor down~nReason: ~p",
-                  [ClientId, Pid, Reason]),
-  {stop, {consumers_sup_down, Reason}, State};
+    Endpoints = State0#state.bootstrap_endpoints,
+    State1 = ensure_metadata_connection(State0),
+    {ok, ProducersSupPid} = brod_producers_sup:start_link(),
+    {ok, ConsumersSupPid} = brod_consumers_sup:start_link(),
+    State2 = State1#state{
+        bootstrap_endpoints = Endpoints,
+        producers_sup = ProducersSupPid,
+        consumers_sup = ConsumersSupPid
+    },
+
+    State = State2#state{partitions_sync = maybe_start_partitions_sync(State2)},
+
+    {noreply, State};
+handle_info(
+    {'EXIT', Pid, Reason},
+    #state{
+        client_id = ClientId,
+        producers_sup = Pid
+    } = State
+) ->
+    ?BROD_LOG_ERROR(
+        "client ~p producers supervisor down~nReason: ~p",
+        [ClientId, Pid, Reason]
+    ),
+    {stop, {producers_sup_down, Reason}, State};
+handle_info(
+    {'EXIT', Pid, Reason},
+    #state{
+        client_id = ClientId,
+        consumers_sup = Pid
+    } = State
+) ->
+    ?BROD_LOG_ERROR(
+        "client ~p consumers supervisor down~nReason: ~p",
+        [ClientId, Pid, Reason]
+    ),
+    {stop, {consumers_sup_down, Reason}, State};
+handle_info(
+    {'EXIT', Pid, Reason},
+    #state{
+        client_id = ClientId,
+        partitions_sync = Pid
+    } = State
+) ->
+    ?BROD_LOG_ERROR("client ~p partitions sync down~nReason: ~p", [ClientId, Pid, Reason]),
+    {noreply, State#state{partitions_sync = maybe_start_partitions_sync(State)}};
 handle_info({'EXIT', Pid, Reason}, State) ->
-  NewState = handle_connection_down(State, Pid, Reason),
-  {noreply, NewState};
+    NewState = handle_connection_down(State, Pid, Reason),
+    {noreply, NewState};
 handle_info(Info, State) ->
-  ?BROD_LOG_WARNING("~p [~p] ~p got unexpected info: ~p",
-                    [?MODULE, self(), State#state.client_id, Info]),
-  {noreply, State}.
+    ?BROD_LOG_WARNING(
+        "~p [~p] ~p got unexpected info: ~p",
+        [?MODULE, self(), State#state.client_id, Info]
+    ),
+    {noreply, State}.
 
 %% @private
 handle_call({stop_producer, Topic}, _From, State) ->
-  ok = brod_producers_sup:stop_producer(State#state.producers_sup, Topic),
-  {reply, ok, State};
+    ok = brod_producers_sup:stop_producer(State#state.producers_sup, Topic),
+    {reply, ok, State};
 handle_call({stop_consumer, Topic}, _From, State) ->
-  Reply = brod_consumers_sup:stop_consumer(State#state.consumers_sup, Topic),
-  {reply, Reply, State};
+    Reply = brod_consumers_sup:stop_consumer(State#state.consumers_sup, Topic),
+    {reply, Reply, State};
 handle_call({get_leader_connection, Topic, Partition}, _From, State) ->
-  {Result, NewState} = do_get_leader_connection(State, Topic, Partition),
-  {reply, Result, NewState};
+    {Result, NewState} = do_get_leader_connection(State, Topic, Partition),
+    {reply, Result, NewState};
 handle_call(get_bootstrap, _From, State) ->
-  #state{bootstrap_endpoints = Endpoints} = State,
-  ConnConfig = conn_config(State),
-  {reply, {ok, {Endpoints, ConnConfig}}, State};
+    #state{bootstrap_endpoints = Endpoints} = State,
+    ConnConfig = conn_config(State),
+    {reply, {ok, {Endpoints, ConnConfig}}, State};
 handle_call({get_connection, Host, Port}, _From, State) ->
-  {Result, NewState} = maybe_connect(State, {Host, Port}),
-  {reply, Result, NewState};
+    {Result, NewState} = maybe_connect(State, {Host, Port}),
+    {reply, Result, NewState};
 handle_call({get_group_coordinator, GroupId}, _From, State) ->
-  {Result, NewState} = do_get_group_coordinator(State, GroupId),
-  {reply, Result, NewState};
+    {Result, NewState} = do_get_group_coordinator(State, GroupId),
+    {reply, Result, NewState};
 handle_call({get_transactional_coordinator, TransactionId}, _From, State) ->
-  {Result, NewState} = do_get_transactional_coordinator(State, TransactionId),
-  {reply, Result, NewState};
+    {Result, NewState} = do_get_transactional_coordinator(State, TransactionId),
+    {reply, Result, NewState};
 handle_call({start_producer, TopicName, ProducerConfig}, _From, State) ->
-  {Reply, NewState} = do_start_producer(TopicName, ProducerConfig, State),
-  {reply, Reply, NewState};
+    {Reply, NewState} = do_start_producer(TopicName, ProducerConfig, State),
+    {reply, Reply, NewState};
 handle_call({start_consumer, TopicName, ConsumerConfig}, _From, State) ->
-  {Reply, NewState} = do_start_consumer(TopicName, ConsumerConfig, State),
-  {reply, Reply, NewState};
+    {Reply, NewState} = do_start_consumer(TopicName, ConsumerConfig, State),
+    {reply, Reply, NewState};
 handle_call({auto_start_producer, Topic}, _From, State) ->
-  Config = State#state.config,
-  case config(auto_start_producers, Config, false) of
-    true ->
-      ProducerConfig = config(default_producer_config, Config, []),
-      {Reply, NewState} = do_start_producer(Topic, ProducerConfig, State),
-      {reply, Reply, NewState};
-    false ->
-      {reply, {error, disabled}, State}
-  end;
+    Config = State#state.config,
+    case config(auto_start_producers, Config, false) of
+        true ->
+            ProducerConfig = config(default_producer_config, Config, []),
+            {Reply, NewState} = do_start_producer(Topic, ProducerConfig, State),
+            {reply, Reply, NewState};
+        false ->
+            {reply, {error, disabled}, State}
+    end;
 handle_call(get_workers_table, _From, State) ->
-  {reply, {ok, State#state.workers_tab}, State};
+    {reply, {ok, State#state.workers_tab}, State};
 handle_call(get_producers_sup_pid, _From, State) ->
-  {reply, {ok, State#state.producers_sup}, State};
+    {reply, {ok, State#state.producers_sup}, State};
 handle_call(get_consumers_sup_pid, _From, State) ->
-  {reply, {ok, State#state.consumers_sup}, State};
+    {reply, {ok, State#state.consumers_sup}, State};
 handle_call({get_metadata, Topic}, _From, State) ->
-  {Result, NewState} = do_get_metadata(Topic, State),
-  {reply, Result, NewState};
+    {Result, NewState} = do_get_metadata(Topic, State),
+    {reply, Result, NewState};
 handle_call(stop, _From, State) ->
-  {stop, normal, ok, State};
+    {stop, normal, ok, State};
 handle_call(Call, _From, State) ->
-  {reply, {error, {unknown_call, Call}}, State}.
+    {reply, {error, {unknown_call, Call}}, State}.
 
 %% @private
 handle_cast({register, Key, Pid}, #state{workers_tab = Tab} = State) ->
-  ets:insert(Tab, {Key, Pid}),
-  {noreply, State};
+    ets:insert(Tab, {Key, Pid}),
+    {noreply, State};
 handle_cast({deregister, Key}, #state{workers_tab = Tab} = State) ->
-  ets:delete(Tab, Key),
-  {noreply, State};
+    ets:delete(Tab, Key),
+    {noreply, State};
 handle_cast(Cast, State) ->
-  ?BROD_LOG_WARNING("~p [~p] ~p got unexpected cast: ~p",
-                    [?MODULE, self(), State#state.client_id, Cast]),
-  {noreply, State}.
+    ?BROD_LOG_WARNING(
+        "~p [~p] ~p got unexpected cast: ~p",
+        [?MODULE, self(), State#state.client_id, Cast]
+    ),
+    {noreply, State}.
 
 %% @private
 code_change(_OldVsn, State, _Extra) ->
-  {ok, State}.
+    {ok, State}.
 
 %% @private
-terminate(Reason, #state{ client_id     = ClientId
-                        , meta_conn     = MetaConn
-                        , payload_conns = PayloadConns
-                        , producers_sup = ProducersSup
-                        , consumers_sup = ConsumersSup
-                        }) ->
-  case brod_utils:is_normal_reason(Reason) of
-    true ->
-      ok;
-    false ->
-      ?BROD_LOG_WARNING("~p [~p] ~p is terminating\nreason: ~p~n",
-                        [?MODULE, self(), ClientId, Reason])
-  end,
-  %% stop producers and consumers first because they are monitoring connections
-  shutdown_pid(ProducersSup),
-  shutdown_pid(ConsumersSup),
-  Shutdown = fun(#conn{pid = Pid}) -> shutdown_pid(Pid) end,
-  lists:foreach(Shutdown, PayloadConns),
-  shutdown_pid(MetaConn).
+terminate(Reason, #state{
+    client_id = ClientId,
+    meta_conn = MetaConn,
+    payload_conns = PayloadConns,
+    producers_sup = ProducersSup,
+    consumers_sup = ConsumersSup
+}) ->
+    case brod_utils:is_normal_reason(Reason) of
+        true ->
+            ok;
+        false ->
+            ?BROD_LOG_WARNING(
+                "~p [~p] ~p is terminating\nreason: ~p~n",
+                [?MODULE, self(), ClientId, Reason]
+            )
+    end,
+    %% stop producers and consumers first because they are monitoring connections
+    shutdown_pid(ProducersSup),
+    shutdown_pid(ConsumersSup),
+    Shutdown = fun(#conn{pid = Pid}) -> shutdown_pid(Pid) end,
+    lists:foreach(Shutdown, PayloadConns),
+    shutdown_pid(MetaConn).
 
 %%%_* Internal Functions =======================================================
 
 shutdown_pid(Pid) when is_pid(Pid) ->
-  exit(Pid, shutdown),
-  ok;
+    exit(Pid, shutdown),
+    ok;
 shutdown_pid(_) ->
-  ok.
+    ok.
 
 -spec get_partition_worker(client(), partition_worker_key()) ->
-        {ok, pid()} | {error, get_worker_error()}.
+    {ok, pid()} | {error, get_worker_error()}.
 get_partition_worker(ClientPid, Key) when is_pid(ClientPid) ->
-  case erlang:process_info(ClientPid, registered_name) of
-    {registered_name, ClientId} -> get_partition_worker(ClientId, Key);
-
-    _ ->
-      %% This is a client process started without registered name
-      %% have to call the process to get the producer/consumer worker
-      %% process registration table.
-      get_partition_worker_with_ets(ClientPid, Key)
-  end;
-
+    case erlang:process_info(ClientPid, registered_name) of
+        {registered_name, ClientId} ->
+            get_partition_worker(ClientId, Key);
+        _ ->
+            %% This is a client process started without registered name
+            %% have to call the process to get the producer/consumer worker
+            %% process registration table.
+            get_partition_worker_with_ets(ClientPid, Key)
+    end;
 get_partition_worker(ClientId, Key) when is_atom(ClientId) ->
-  case lookup_partition_worker(ClientId, ?ETS(ClientId), Key) of
-    {ok, Pid} ->
-      %% This is an attempt to help with a race condition
-      %% between ets lookups and what is being supervised.
-      %% If the worker process is returned form ets,
-      %% but it is not alive then there must be
-      %% an in-flight worker deregistration request.
-      case is_pid(Pid) andalso is_process_alive(Pid) of
-        true -> {ok, Pid};
-        false -> get_partition_worker_with_ets(ClientId, Key)
-      end;
-    Other -> Other
-  end.
+    case lookup_partition_worker(ClientId, ?ETS(ClientId), Key) of
+        {ok, Pid} ->
+            %% This is an attempt to help with a race condition
+            %% between ets lookups and what is being supervised.
+            %% If the worker process is returned form ets,
+            %% but it is not alive then there must be
+            %% an in-flight worker deregistration request.
+            case is_pid(Pid) andalso is_process_alive(Pid) of
+                true -> {ok, Pid};
+                false -> get_partition_worker_with_ets(ClientId, Key)
+            end;
+        Other ->
+            Other
+    end.
 
 -spec get_partition_worker_with_ets(client(), partition_worker_key()) ->
-  {ok, pid()} | {error, get_worker_error()}.
+    {ok, pid()} | {error, get_worker_error()}.
 get_partition_worker_with_ets(Client, Key) ->
-  case safe_gen_call(Client, get_workers_table, infinity) of
-    {ok, Ets} -> lookup_partition_worker(Client, Ets, Key);
-    {error, Reason} -> {error, Reason}
-  end.
+    case safe_gen_call(Client, get_workers_table, infinity) of
+        {ok, Ets} -> lookup_partition_worker(Client, Ets, Key);
+        {error, Reason} -> {error, Reason}
+    end.
 
 -spec lookup_partition_worker(client(), ets:tab(), partition_worker_key()) ->
-        {ok, pid()} | { error, get_worker_error()}.
+    {ok, pid()} | {error, get_worker_error()}.
 lookup_partition_worker(Client, Ets, Key) ->
-  try ets:lookup(Ets, Key) of
-    [] ->
-      %% not yet registered, 2 possible reasons:
-      %% 1. caller is too fast, producers/consumers are starting up
-      %%    make a synced call all the way down the supervision tree
-      %%    to the partition producer sup should resolve the race
-      %% 2. bad argument, no such worker started, supervisors should know
-      find_partition_worker(Client, Key);
-    [?PRODUCER(_Topic, _Partition, Pid)] ->
-      {ok, Pid};
-    [?CONSUMER(_Topic, _Partition, Pid)] ->
-      {ok, Pid}
-  catch
-    error : badarg ->
-      {error, client_down}
-  end.
+    try ets:lookup(Ets, Key) of
+        [] ->
+            %% not yet registered, 2 possible reasons:
+            %% 1. caller is too fast, producers/consumers are starting up
+            %%    make a synced call all the way down the supervision tree
+            %%    to the partition producer sup should resolve the race
+            %% 2. bad argument, no such worker started, supervisors should know
+            find_partition_worker(Client, Key);
+        [?PRODUCER(_Topic, _Partition, Pid)] ->
+            {ok, Pid};
+        [?CONSUMER(_Topic, _Partition, Pid)] ->
+            {ok, Pid}
+    catch
+        error:badarg ->
+            {error, client_down}
+    end.
 
 -spec find_partition_worker(client(), partition_worker_key()) ->
-        {ok, pid()} | {error, get_worker_error()}.
+    {ok, pid()} | {error, get_worker_error()}.
 find_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) ->
-  find_producer(Client, Topic, Partition);
+    find_producer(Client, Topic, Partition);
 find_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)) ->
-  find_consumer(Client, Topic, Partition).
+    find_consumer(Client, Topic, Partition).
 
 -spec find_producer(client(), topic(), partition()) ->
-        {ok, pid()} | {error, get_producer_error()}.
+    {ok, pid()} | {error, get_producer_error()}.
 find_producer(Client, Topic, Partition) ->
-  case safe_gen_call(Client, get_producers_sup_pid, infinity) of
-    {ok, SupPid} ->
-      brod_producers_sup:find_producer(SupPid, Topic, Partition);
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    case safe_gen_call(Client, get_producers_sup_pid, infinity) of
+        {ok, SupPid} ->
+            brod_producers_sup:find_producer(SupPid, Topic, Partition);
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 -spec find_consumer(client(), topic(), partition()) ->
-        {ok, pid()} | {error, get_consumer_error()}.
+    {ok, pid()} | {error, get_consumer_error()}.
 find_consumer(Client, Topic, Partition) ->
-  case safe_gen_call(Client, get_consumers_sup_pid, infinity) of
-    {ok, SupPid} ->
-      brod_consumers_sup:find_consumer(SupPid, Topic, Partition);
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    case safe_gen_call(Client, get_consumers_sup_pid, infinity) of
+        {ok, SupPid} ->
+            brod_consumers_sup:find_consumer(SupPid, Topic, Partition);
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 -spec validate_topic_existence(topic(), state(), boolean()) ->
-        {Result, state()} when Result :: ok | {error, any()}.
+    {Result, state()}
+when
+    Result :: ok | {error, any()}.
 validate_topic_existence(Topic, #state{workers_tab = Ets} = State, IsRetry) ->
-  case lookup_partitions_count_cache(Ets, Topic) of
-    {ok, _Count} ->
-      {ok, State};
-    {error, Reason} ->
-      {{error, Reason}, State};
-    false when IsRetry ->
-      {{error, ?unknown_topic_or_partition}, State};
-    false ->
-      %% Try fetch metadata (and populate partition count cache)
-      %% Then validate topic existence again.
-      with_ok(do_get_metadata_safe(Topic, State),
-              fun(_, S) -> validate_topic_existence(Topic, S, true) end)
-  end.
+    case lookup_partitions_count_cache(Ets, Topic) of
+        {ok, _Count} ->
+            {ok, State};
+        {error, Reason} ->
+            {{error, Reason}, State};
+        false when IsRetry ->
+            {{error, ?unknown_topic_or_partition}, State};
+        false ->
+            %% Try fetch metadata (and populate partition count cache)
+            %% Then validate topic existence again.
+            with_ok(
+                do_get_metadata_safe(Topic, State),
+                fun(_, S) -> validate_topic_existence(Topic, S, true) end
+            )
+    end.
 
 %% Continue with {{ok, Result}, NewState}
 %% return whatever error immediately.
 -spec with_ok(Result, fun((_, state()) -> Result)) ->
-        Result when Result :: {ok | {ok, term()} | {error, any()}, state()}.
+    Result
+when
+    Result :: {ok | {ok, term()} | {error, any()}, state()}.
 with_ok({ok, State}, Continue) -> Continue(ok, State);
 with_ok({{ok, OK}, State}, Continue) -> Continue(OK, State);
 with_ok({{error, _}, #state{}} = Return, _Continue) -> Return.
@@ -602,224 +643,248 @@ with_ok({{error, _}, #state{}} = Return, _Continue) -> Return.
 %% do not try to fetch metadata per topic name, fetch all topics instead.
 %% As sending metadata request with topic name will cause an auto creation
 %% of the topic if auto.create.topics.enable is enabled in broker config.
--spec do_get_metadata_safe(topic(), state()) -> {Result, state()}
-        when Result :: {ok, kpro:struct()} | {error, any()}.
+-spec do_get_metadata_safe(topic(), state()) -> {Result, state()} when
+    Result :: {ok, kpro:struct()} | {error, any()}.
 do_get_metadata_safe(Topic0, #state{config = Config} = State) ->
-  Topic =
-    case config(allow_topic_auto_creation, Config, true) of
-      true  -> Topic0;
-      false -> {all, Topic0}
-    end,
-  do_get_metadata(Topic, State).
+    Topic =
+        case config(allow_topic_auto_creation, Config, true) of
+            true -> Topic0;
+            false -> {all, Topic0}
+        end,
+    do_get_metadata(Topic, State).
 
--spec do_get_metadata(all | topic() | {all, topic()}, state()) -> {Result, state()}
-        when Result :: {ok, kpro:struct()} | {error, any()}.
+-spec do_get_metadata(all | topic() | {all, topic()}, state()) -> {Result, state()} when
+    Result :: {ok, kpro:struct()} | {error, any()}.
 do_get_metadata({all, Topic}, State) ->
     do_get_metadata(all, Topic, State);
 do_get_metadata(Topic, State) when not is_tuple(Topic) ->
     do_get_metadata(Topic, Topic, State).
 
-do_get_metadata(FetchMetadataFor, Topic,
-                #state{ client_id   = ClientId
-                      , workers_tab = Ets
-                      , config = Config
-                      } = State0) ->
-  Topics = case FetchMetadataFor of
-             all -> all; %% in case no topic is given, get all
-             _   -> [Topic]
-           end,
-  State = ensure_metadata_connection(State0),
-  Conn = get_metadata_connection(State),
-  Request = brod_kafka_request:metadata(Conn, Topics),
-  case request_sync(State, Request) of
-    {ok, #kpro_rsp{api = metadata, msg = Metadata}} ->
-      TopicMetadataArray = kf(topics, Metadata),
-      UnknownTopicCacheTtl = config(unknown_topic_cache_ttl, Config,
-                                    ?DEFAULT_UNKNOWN_TOPIC_CACHE_TTL),
-      ok = update_partitions_count_cache(Ets, TopicMetadataArray, UnknownTopicCacheTtl),
-      ok = maybe_cache_unknown_topic_partition(Ets, Topic, TopicMetadataArray,
-                                               UnknownTopicCacheTtl),
-      {{ok, Metadata}, State};
-    {error, Reason} ->
-      ?BROD_LOG_ERROR("~p failed to fetch metadata for topics: ~p\n"
-                      "reason=~p",
-                      [ClientId, Topics, Reason]),
-      {{error, Reason}, State}
-  end.
+do_get_metadata(
+    FetchMetadataFor,
+    Topic,
+    #state{
+        client_id = ClientId,
+        workers_tab = Ets,
+        config = Config
+    } = State0
+) ->
+    Topics =
+        case FetchMetadataFor of
+            %% in case no topic is given, get all
+            all -> all;
+            _ -> [Topic]
+        end,
+    State = ensure_metadata_connection(State0),
+    Conn = get_metadata_connection(State),
+    Request = brod_kafka_request:metadata(Conn, Topics),
+    case request_sync(State, Request) of
+        {ok, #kpro_rsp{api = metadata, msg = Metadata}} ->
+            TopicMetadataArray = kf(topics, Metadata),
+            UnknownTopicCacheTtl = config(
+                unknown_topic_cache_ttl,
+                Config,
+                ?DEFAULT_UNKNOWN_TOPIC_CACHE_TTL
+            ),
+            ok = update_partitions_count_cache(Ets, TopicMetadataArray, UnknownTopicCacheTtl),
+            ok = maybe_cache_unknown_topic_partition(
+                Ets,
+                Topic,
+                TopicMetadataArray,
+                UnknownTopicCacheTtl
+            ),
+            {{ok, Metadata}, State};
+        {error, Reason} ->
+            ?BROD_LOG_ERROR(
+                "~p failed to fetch metadata for topics: ~p\n"
+                "reason=~p",
+                [ClientId, Topics, Reason]
+            ),
+            {{error, Reason}, State}
+    end.
 
 %% Ensure there is at least one metadata connection
-ensure_metadata_connection(#state{ bootstrap_endpoints = Endpoints
-                                 , meta_conn = ?undef
-                                 } = State) ->
-  ConnConfig = conn_config(State),
-  Pid = case kpro:connect_any(Endpoints, ConnConfig) of
-          {ok, PidX} -> PidX;
-          {error, Reason} -> erlang:exit(Reason)
+ensure_metadata_connection(
+    #state{
+        bootstrap_endpoints = Endpoints,
+        meta_conn = ?undef
+    } = State
+) ->
+    ConnConfig = conn_config(State),
+    Pid =
+        case kpro:connect_any(Endpoints, ConnConfig) of
+            {ok, PidX} -> PidX;
+            {error, Reason} -> erlang:exit(Reason)
         end,
-  State#state{meta_conn = Pid};
+    State#state{meta_conn = Pid};
 ensure_metadata_connection(State) ->
-  State.
+    State.
 
 %% must be called after ensure_metadata_connection
 get_metadata_connection(#state{meta_conn = Conn}) -> Conn.
 
 do_get_leader_connection(State0, Topic, Partition) ->
-  State = ensure_metadata_connection(State0),
-  MetaConn = get_metadata_connection(State),
-  Timeout = timeout(State),
-  case kpro:discover_partition_leader(MetaConn, Topic, Partition, Timeout) of
-    {ok, Endpoint} -> maybe_connect(State, Endpoint);
-    {error, Reason} -> {{error, Reason}, State}
-  end.
+    State = ensure_metadata_connection(State0),
+    MetaConn = get_metadata_connection(State),
+    Timeout = timeout(State),
+    case kpro:discover_partition_leader(MetaConn, Topic, Partition, Timeout) of
+        {ok, Endpoint} -> maybe_connect(State, Endpoint);
+        {error, Reason} -> {{error, Reason}, State}
+    end.
 
 -spec do_get_group_coordinator(state(), group_id()) ->
-        {Result, state()} when Result :: {ok, connection()} | {error, any()}.
+    {Result, state()}
+when
+    Result :: {ok, connection()} | {error, any()}.
 do_get_group_coordinator(State0, GroupId) ->
-  State = ensure_metadata_connection(State0),
-  MetaConn = get_metadata_connection(State),
-  Timeout = timeout(State),
-  case kpro:discover_coordinator(MetaConn, group, GroupId, Timeout) of
-    {ok, Endpoint} ->
-      {{ok, {Endpoint, conn_config(State)}}, State};
-    {error, Reason} ->
-      {{error, Reason}, State}
-  end.
+    State = ensure_metadata_connection(State0),
+    MetaConn = get_metadata_connection(State),
+    Timeout = timeout(State),
+    case kpro:discover_coordinator(MetaConn, group, GroupId, Timeout) of
+        {ok, Endpoint} ->
+            {{ok, {Endpoint, conn_config(State)}}, State};
+        {error, Reason} ->
+            {{error, Reason}, State}
+    end.
 
 -spec do_get_transactional_coordinator(state(), transactional_id()) ->
-        {Result, state()} when Result :: {ok, connection()} | {error, any()}.
+    {Result, state()}
+when
+    Result :: {ok, connection()} | {error, any()}.
 do_get_transactional_coordinator(State0, TransactionId) ->
-  State = ensure_metadata_connection(State0),
-  MetaConn = get_metadata_connection(State),
-  Timeout = timeout(State),
-  case kpro:discover_coordinator(MetaConn, txn, TransactionId, Timeout) of
-    {ok, Endpoint} ->
-      {{ok, {Endpoint, conn_config(State)}}, State};
-    {error, Reason} ->
-      {{error, Reason}, State}
-  end.
+    State = ensure_metadata_connection(State0),
+    MetaConn = get_metadata_connection(State),
+    Timeout = timeout(State),
+    case kpro:discover_coordinator(MetaConn, txn, TransactionId, Timeout) of
+        {ok, Endpoint} ->
+            {{ok, {Endpoint, conn_config(State)}}, State};
+        {error, Reason} ->
+            {{error, Reason}, State}
+    end.
 
 timeout(#state{config = Config}) ->
-  timeout(Config);
+    timeout(Config);
 timeout(Config) ->
-  T = config(get_metadata_timeout_seconds, Config,
-             ?DEFAULT_GET_METADATA_TIMEOUT_SECONDS),
-  timer:seconds(T).
-
-sync_interval(Config) ->
-  T = config(sync_metadata_interval_seconds, Config,
-             ?DEFAULT_SYNC_METADATA_INTERVAL_SECONDS),
-  timer:seconds(T).
+    T = config(
+        get_metadata_timeout_seconds,
+        Config,
+        ?DEFAULT_GET_METADATA_TIMEOUT_SECONDS
+    ),
+    timer:seconds(T).
 
 config(Key, Config, Default) ->
-  proplists:get_value(Key, Config, Default).
+    proplists:get_value(Key, Config, Default).
 
 conn_config(#state{client_id = ClientId, config = Config}) ->
-  Cfg = conn_config(Config, kpro_connection:all_cfg_keys(), []),
-  maps:from_list([{client_id, ensure_binary(ClientId)} | Cfg]).
+    Cfg = conn_config(Config, kpro_connection:all_cfg_keys(), []),
+    maps:from_list([{client_id, ensure_binary(ClientId)} | Cfg]).
 
-conn_config([], _ConnCfgKeys, Acc) -> Acc;
+conn_config([], _ConnCfgKeys, Acc) ->
+    Acc;
 conn_config([{K, V} | Rest], ConnCfgKeys, Acc) ->
-  NewAcc =
-    case lists:member(K, ConnCfgKeys) of
-      true -> [{K, V} | Acc];
-      false -> Acc
-    end,
-  conn_config(Rest, ConnCfgKeys, NewAcc);
+    NewAcc =
+        case lists:member(K, ConnCfgKeys) of
+            true -> [{K, V} | Acc];
+            false -> Acc
+        end,
+    conn_config(Rest, ConnCfgKeys, NewAcc);
 conn_config([K | Rest], ConnCfgKeys, Acc) when is_atom(K) ->
-  %% translate proplist boolean mark to tuple
-  conn_config([{K, true} | Rest], ConnCfgKeys, Acc).
+    %% translate proplist boolean mark to tuple
+    conn_config([{K, true} | Rest], ConnCfgKeys, Acc).
 
 ensure_binary(ClientId) when is_atom(ClientId) ->
-  ensure_binary(atom_to_binary(ClientId, utf8));
+    ensure_binary(atom_to_binary(ClientId, utf8));
 ensure_binary(ClientId) when is_binary(ClientId) ->
-  ClientId.
-
-maybe_start_metadata_sync(Config) ->
-  case config(sync_metadata, Config, false) of
-    true ->
-      erlang:send_after(sync_interval(Config), self(), sync);
-    false ->
-      undefined
-  end.
-
-sync_topics_metadata(Children, State) ->
-  lists:foldl(fun({Topic, _, _, _}, StateAcc) -> sync_topic_metadata(Topic, StateAcc) end, State, Children).
-
-sync_topic_metadata(Topic, State) ->
-  case do_get_metadata(Topic, State) of
-    {{ok, #{ topics := [ #{ partitions := Partitions } ] }}, NewState} ->
-      lists:foreach(fun (Partition) -> sync_topic_partition(Partition, Topic, State) end, Partitions),
-      NewState;
-    {{error, _}, NewState} ->
-      NewState
-  end.
-
-sync_topic_partition(#{ partition_index := Partition }, Topic, #state{ producers_sup = Sup, client_id = Client, config = Config}) ->
-  case brod_producers_sup:find_producer(Sup, Topic, Partition) of
-    {ok, _} ->
-      ok;
-    {error, {producer_not_found, _, _}} ->
-      brod_producer:start_link(Client, Topic, Partition, Config)
-  end.
+    ClientId.
+
+maybe_start_partitions_sync(#state{
+    client_id = Client, producers_sup = ProducersSup, config = Config
+}) ->
+    case config(sync_partitions, Config, false) of
+        true ->
+            {ok, Pid} = brod_partitions_sync:start_link(Client, ProducersSup, Config),
+            Pid;
+        false ->
+            undefined
+    end.
 
 -spec maybe_connect(state(), endpoint()) ->
-        {Result, state()} when Result :: {ok, pid()} | {error, any()}.
+    {Result, state()}
+when
+    Result :: {ok, pid()} | {error, any()}.
 maybe_connect(#state{} = State, Endpoint) ->
-  case find_conn(Endpoint, State#state.payload_conns) of
-    {ok, Pid} -> {{ok, Pid}, State};
-    {error, Reason} -> maybe_connect(State, Endpoint, Reason)
-  end.
+    case find_conn(Endpoint, State#state.payload_conns) of
+        {ok, Pid} -> {{ok, Pid}, State};
+        {error, Reason} -> maybe_connect(State, Endpoint, Reason)
+    end.
 
 -spec maybe_connect(state(), endpoint(), Reason) ->
-        {Result, state()} when
-          Reason :: not_found | dead_conn(),
-          Result :: {ok, pid()} | {error, any()}.
+    {Result, state()}
+when
+    Reason :: not_found | dead_conn(),
+    Result :: {ok, pid()} | {error, any()}.
 maybe_connect(State, Endpoint, not_found) ->
-  %% connect for the first time
-  connect(State, Endpoint);
-maybe_connect(#state{client_id = ClientId} = State,
-              {Host, Port} = Endpoint, ?dead_since(Ts, Reason)) ->
-  case is_cooled_down(Ts, State) of
-    true ->
-      connect(State, Endpoint);
-    false ->
-      ?BROD_LOG_ERROR("~p (re)connect to ~s:~p aborted.\n"
-                      "last failure: ~p",
-                      [ClientId, Host, Port, Reason]),
-     {{error, Reason}, State}
-  end.
-
--spec connect(state(), endpoint()) -> {Result, state()}
-        when Result :: {ok, pid()} | {error, any()}.
-connect(#state{ client_id = ClientId
-              , payload_conns = Conns
-              } = State, {Host, Port} = Endpoint) ->
-  Conn =
-    case do_connect(Endpoint, State) of
-      {ok, Pid} ->
-        ?BROD_LOG_INFO("client ~p connected to ~s:~p~n",
-                       [ClientId, Host, Port]),
-        #conn{ endpoint = Endpoint
-             , pid = Pid
-             };
-      {error, Reason} ->
-        ?BROD_LOG_ERROR("client ~p failed to connect to ~s:~p~n"
-                        "reason:~p",
-                        [ClientId, Host, Port, Reason]),
-        #conn{ endpoint = Endpoint
-             , pid = mark_dead(Reason)
-             }
-    end,
-  NewConns = lists:keystore(Endpoint, #conn.endpoint, Conns, Conn),
-  Result = case Conn#conn.pid of
-             P when is_pid(P) -> {ok, P};
-             ?dead_since(_, R) -> {error, R}
-           end,
-  {Result, State#state{payload_conns = NewConns}}.
+    %% connect for the first time
+    connect(State, Endpoint);
+maybe_connect(
+    #state{client_id = ClientId} = State,
+    {Host, Port} = Endpoint,
+    ?dead_since(Ts, Reason)
+) ->
+    case is_cooled_down(Ts, State) of
+        true ->
+            connect(State, Endpoint);
+        false ->
+            ?BROD_LOG_ERROR(
+                "~p (re)connect to ~s:~p aborted.\n"
+                "last failure: ~p",
+                [ClientId, Host, Port, Reason]
+            ),
+            {{error, Reason}, State}
+    end.
+
+-spec connect(state(), endpoint()) -> {Result, state()} when
+    Result :: {ok, pid()} | {error, any()}.
+connect(
+    #state{
+        client_id = ClientId,
+        payload_conns = Conns
+    } = State,
+    {Host, Port} = Endpoint
+) ->
+    Conn =
+        case do_connect(Endpoint, State) of
+            {ok, Pid} ->
+                ?BROD_LOG_INFO(
+                    "client ~p connected to ~s:~p~n",
+                    [ClientId, Host, Port]
+                ),
+                #conn{
+                    endpoint = Endpoint,
+                    pid = Pid
+                };
+            {error, Reason} ->
+                ?BROD_LOG_ERROR(
+                    "client ~p failed to connect to ~s:~p~n"
+                    "reason:~p",
+                    [ClientId, Host, Port, Reason]
+                ),
+                #conn{
+                    endpoint = Endpoint,
+                    pid = mark_dead(Reason)
+                }
+        end,
+    NewConns = lists:keystore(Endpoint, #conn.endpoint, Conns, Conn),
+    Result =
+        case Conn#conn.pid of
+            P when is_pid(P) -> {ok, P};
+            ?dead_since(_, R) -> {error, R}
+        end,
+    {Result, State#state{payload_conns = NewConns}}.
 
 do_connect(Endpoint, State) ->
-  ConnConfig = conn_config(State),
-  kpro:connect(Endpoint, ConnConfig).
+    ConnConfig = conn_config(State),
+    kpro:connect(Endpoint, ConnConfig).
 
 %% Handle connection pid EXIT event, for payload sockets keep the timestamp,
 %% but do not restart yet. Payload connection will be re-established when a
@@ -827,208 +892,244 @@ do_connect(Endpoint, State) ->
 %% it is cooled down.
 -spec handle_connection_down(state(), pid(), any()) -> state().
 handle_connection_down(#state{meta_conn = Pid} = State, Pid, _Reason) ->
-  State#state{meta_conn = ?undef};
-handle_connection_down(#state{ payload_conns = Conns
-                             , client_id     = ClientId
-                             } = State, Pid, Reason) ->
-  case lists:keytake(Pid, #conn.pid, Conns) of
-    {value, #conn{endpoint = {Host, Port}} = Conn, Rest} ->
-      ?BROD_LOG_INFO("client ~p: payload connection down ~s:~p~n"
-                     "reason:~p", [ClientId, Host, Port, Reason]),
-      NewConn = Conn#conn{pid = mark_dead(Reason)},
-      State#state{payload_conns = [NewConn | Rest]};
-    false ->
-      %% stale EXIT message
-      State
-  end.
+    State#state{meta_conn = ?undef};
+handle_connection_down(
+    #state{
+        payload_conns = Conns,
+        client_id = ClientId
+    } = State,
+    Pid,
+    Reason
+) ->
+    case lists:keytake(Pid, #conn.pid, Conns) of
+        {value, #conn{endpoint = {Host, Port}} = Conn, Rest} ->
+            ?BROD_LOG_INFO(
+                "client ~p: payload connection down ~s:~p~n"
+                "reason:~p",
+                [ClientId, Host, Port, Reason]
+            ),
+            NewConn = Conn#conn{pid = mark_dead(Reason)},
+            State#state{payload_conns = [NewConn | Rest]};
+        false ->
+            %% stale EXIT message
+            State
+    end.
 
 mark_dead(Reason) -> ?dead_since(os:timestamp(), Reason).
 
 -spec find_conn(endpoint(), [conn_state()]) ->
-        {ok, pid()} %% normal case
-      | {error, not_found} %% first call
-      | {error, dead_conn()}.
+    %% normal case
+    {ok, pid()}
+    %% first call
+    | {error, not_found}
+    | {error, dead_conn()}.
 find_conn(Endpoint, Conns) ->
-  case lists:keyfind(Endpoint, #conn.endpoint, Conns) of
-    #conn{pid = Pid} when is_pid(Pid)        -> {ok, Pid};
-    #conn{pid= ?dead_since(_, _) = NotAlive} -> {error, NotAlive};
-    false                                    -> {error, not_found}
-  end.
+    case lists:keyfind(Endpoint, #conn.endpoint, Conns) of
+        #conn{pid = Pid} when is_pid(Pid) -> {ok, Pid};
+        #conn{pid = ?dead_since(_, _) = NotAlive} -> {error, NotAlive};
+        false -> {error, not_found}
+    end.
 
 %% Check if the connection is down for long enough to retry.
 is_cooled_down(Ts, #state{config = Config}) ->
-  Threshold = config(reconnect_cool_down_seconds, Config,
-                     ?DEFAULT_RECONNECT_COOL_DOWN_SECONDS),
-  Now = os:timestamp(),
-  Diff = timer:now_diff(Now, Ts) div 1000000,
-  Diff >= Threshold.
+    Threshold = config(
+        reconnect_cool_down_seconds,
+        Config,
+        ?DEFAULT_RECONNECT_COOL_DOWN_SECONDS
+    ),
+    Now = os:timestamp(),
+    Diff = timer:now_diff(Now, Ts) div 1000000,
+    Diff >= Threshold.
 
 %% call this function after fetched metadata for all topics
 %% to cache the not-found status of a given topic
 maybe_cache_unknown_topic_partition(Ets, Topic, TopicMetadataArray, UnknownTopicCacheTtl) ->
-  case find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic) of
-    {error, unknown_topic_or_partition} = Err ->
-      _ = ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Err,
-                     {expire, expire_ts(UnknownTopicCacheTtl)}}),
-      ok;
-    _ ->
-      %% do nothing when ok or any other error
-      ok
-  end.
+    case find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic) of
+        {error, unknown_topic_or_partition} = Err ->
+            _ = ets:insert(Ets, {
+                ?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}
+            }),
+            ok;
+        _ ->
+            %% do nothing when ok or any other error
+            ok
+    end.
 
 -spec update_partitions_count_cache(ets:tab(), [kpro:struct()], non_neg_integer()) -> ok.
-update_partitions_count_cache(_Ets, [], _UnknownTopicCacheTtl) -> ok;
+update_partitions_count_cache(_Ets, [], _UnknownTopicCacheTtl) ->
+    ok;
 update_partitions_count_cache(Ets, [TopicMetadata | Rest], UnknownTopicCacheTtl) ->
-  Topic = kf(name, TopicMetadata),
-  case get_partitions_count_in_metadata(TopicMetadata) of
-    {ok, Cnt} ->
-      ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Cnt, {added, now_ts()}});
-    {error, ?unknown_topic_or_partition} = Err ->
-      ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}});
-    {error, _Reason} ->
-      ok
-  end,
-  update_partitions_count_cache(Ets, Rest, UnknownTopicCacheTtl).
+    Topic = kf(name, TopicMetadata),
+    case get_partitions_count_in_metadata(TopicMetadata) of
+        {ok, Cnt} ->
+            ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Cnt, {added, now_ts()}});
+        {error, ?unknown_topic_or_partition} = Err ->
+            ets:insert(Ets, {
+                ?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}
+            });
+        {error, _Reason} ->
+            ok
+    end,
+    update_partitions_count_cache(Ets, Rest, UnknownTopicCacheTtl).
 
 %% Get partition counter from cache.
 %% If cache is not hit, send meta data request to retrieve.
--spec do_get_partitions_count(client(), ets:tab(), topic(),
-                              #{allow_topic_auto_creation := boolean()}) ->
-        {ok, pos_integer()} | {error, any()}.
+-spec do_get_partitions_count(
+    client(),
+    ets:tab(),
+    topic(),
+    #{allow_topic_auto_creation := boolean()}
+) ->
+    {ok, pos_integer()} | {error, any()}.
 do_get_partitions_count(Client, Ets, Topic, #{allow_topic_auto_creation := AllowAutoCreation}) ->
-  case lookup_partitions_count_cache(Ets, Topic) of
-    {ok, Result} ->
-      {ok, Result};
-    {error, Reason} ->
-      {error, Reason};
-    false ->
-      %% The topic's partition count is not cached yet,
-      %% try to call get_metadata or get_metadata_safe to populate the cache
-      MetadataResponse =
-        case AllowAutoCreation of
-          true ->
-            get_metadata(Client, Topic);
-          false ->
-            get_metadata_safe(Client, Topic)
-        end,
-      %% the metadata is returned, no need to look up the cache again
-      %% find the topic's partition count from the metadata directly
-      find_partition_count_in_metadata(MetadataResponse, Topic)
-  end.
+    case lookup_partitions_count_cache(Ets, Topic) of
+        {ok, Result} ->
+            {ok, Result};
+        {error, Reason} ->
+            {error, Reason};
+        false ->
+            %% The topic's partition count is not cached yet,
+            %% try to call get_metadata or get_metadata_safe to populate the cache
+            MetadataResponse =
+                case AllowAutoCreation of
+                    true ->
+                        get_metadata(Client, Topic);
+                    false ->
+                        get_metadata_safe(Client, Topic)
+                end,
+            %% the metadata is returned, no need to look up the cache again
+            %% find the topic's partition count from the metadata directly
+            find_partition_count_in_metadata(MetadataResponse, Topic)
+    end.
 
 find_partition_count_in_metadata({ok, Meta}, Topic) ->
-  TopicMetadataArray = kf(topics, Meta),
-  find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic);
+    TopicMetadataArray = kf(topics, Meta),
+    find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic);
 find_partition_count_in_metadata({error, Reason}, _) ->
-  {error, Reason}.
+    {error, Reason}.
 
 find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic) ->
-  FilterF = fun(#{name := N}) when N =:= Topic -> true;
-               (_) -> false
-            end,
-  case lists:filter(FilterF, TopicMetadataArray) of
-    [TopicMetadata] ->
-      get_partitions_count_in_metadata(TopicMetadata);
-    [] ->
-      {error, unknown_topic_or_partition}
-  end.
+    FilterF = fun
+        (#{name := N}) when N =:= Topic -> true;
+        (_) -> false
+    end,
+    case lists:filter(FilterF, TopicMetadataArray) of
+        [TopicMetadata] ->
+            get_partitions_count_in_metadata(TopicMetadata);
+        [] ->
+            {error, unknown_topic_or_partition}
+    end.
 
 -spec lookup_partitions_count_cache(ets:tab(), ?undef | topic()) ->
-        {ok, pos_integer()} | {error, any()} | false.
-lookup_partitions_count_cache(_Ets, ?undef) -> false;
+    {ok, pos_integer()} | {error, any()} | false.
+lookup_partitions_count_cache(_Ets, ?undef) ->
+    false;
 lookup_partitions_count_cache(Ets, Topic) ->
-  try ets:lookup(Ets, ?TOPIC_METADATA_KEY(Topic)) of
-    [{_, Count, _Ts}] when is_integer(Count) ->
-      {ok, Count};
-    [{_, {error, Reason}, {expire, ExpireTs}}] when is_integer(ExpireTs) ->
-      case is_expired(ExpireTs) of
-        true  -> {error, Reason};
-        false -> false
-      end;
-    [] ->
-      false
-  catch
-    error : badarg ->
-      {error, client_down}
-  end.
+    try ets:lookup(Ets, ?TOPIC_METADATA_KEY(Topic)) of
+        [{_, Count, _Ts}] when is_integer(Count) ->
+            {ok, Count};
+        [{_, {error, Reason}, {expire, ExpireTs}}] when is_integer(ExpireTs) ->
+            case is_expired(ExpireTs) of
+                true -> {error, Reason};
+                false -> false
+            end;
+        [] ->
+            false
+    catch
+        error:badarg ->
+            {error, client_down}
+    end.
 
 -spec get_partitions_count_in_metadata(kpro:struct()) ->
-        {ok, pos_integer()} | {error, any()}.
+    {ok, pos_integer()} | {error, any()}.
 get_partitions_count_in_metadata(TopicMetadata) ->
-  ErrorCode = kf(error_code, TopicMetadata),
-  Partitions = kf(partitions, TopicMetadata),
-  case ?IS_ERROR(ErrorCode) of
-    true  -> {error, ErrorCode};
-    false -> {ok, erlang:length(Partitions)}
-  end.
-
--spec maybe_start_producer(client(), topic(),
-                           partition(), {error, any()}) ->
-        ok | {error, any()}.
+    ErrorCode = kf(error_code, TopicMetadata),
+    Partitions = kf(partitions, TopicMetadata),
+    case ?IS_ERROR(ErrorCode) of
+        true -> {error, ErrorCode};
+        false -> {ok, erlang:length(Partitions)}
+    end.
+
+-spec maybe_start_producer(
+    client(),
+    topic(),
+    partition(),
+    {error, any()}
+) ->
+    ok | {error, any()}.
 maybe_start_producer(Client, Topic, Partition, Error) ->
-  %% try to start a producer for the given topic if
-  %% auto_start_producers option is enabled for the client
-  case safe_gen_call(Client, {auto_start_producer, Topic}, infinity) of
-    ok ->
-      get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition));
-    {error, disabled} ->
-      Error;
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    %% try to start a producer for the given topic if
+    %% auto_start_producers option is enabled for the client
+    case safe_gen_call(Client, {auto_start_producer, Topic}, infinity) of
+        ok ->
+            get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition));
+        {error, disabled} ->
+            Error;
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 -spec request_sync(state(), kpro:req()) ->
-        {ok, kpro:rsp()} | {error, any()}.
+    {ok, kpro:rsp()} | {error, any()}.
 request_sync(State, Request) ->
-  Pid = get_metadata_connection(State),
-  Timeout = timeout(State),
-  kpro:request_sync(Pid, Request, Timeout).
+    Pid = get_metadata_connection(State),
+    Timeout = timeout(State),
+    kpro:request_sync(Pid, Request, Timeout).
 
 do_start_producer(TopicName, ProducerConfig, State) ->
-  SupPid = State#state.producers_sup,
-  F = fun() ->
-        brod_producers_sup:start_producer(SupPid, self(),
-                                          TopicName, ProducerConfig)
-      end,
-  ensure_partition_workers(TopicName, State, F).
+    SupPid = State#state.producers_sup,
+    F = fun() ->
+        brod_producers_sup:start_producer(
+            SupPid,
+            self(),
+            TopicName,
+            ProducerConfig
+        )
+    end,
+    ensure_partition_workers(TopicName, State, F).
 
 do_start_consumer(TopicName, ConsumerConfig, State) ->
-  SupPid = State#state.consumers_sup,
-  F = fun() ->
-        brod_consumers_sup:start_consumer(SupPid, self(),
-                                          TopicName, ConsumerConfig)
-      end,
-  ensure_partition_workers(TopicName, State, F).
+    SupPid = State#state.consumers_sup,
+    F = fun() ->
+        brod_consumers_sup:start_consumer(
+            SupPid,
+            self(),
+            TopicName,
+            ConsumerConfig
+        )
+    end,
+    ensure_partition_workers(TopicName, State, F).
 
 ensure_partition_workers(TopicName, State, F) ->
-  with_ok(
-    validate_topic_existence(TopicName, State, _IsRetry = false),
-    fun(ok, NewState) ->
-      case F() of
-        {ok, _Pid} ->
-          {ok, NewState};
-        {error, {already_started, _Pid}} ->
-          {ok, NewState};
-        {error, Reason} ->
-          {{error, Reason}, NewState}
-      end
-    end).
+    with_ok(
+        validate_topic_existence(TopicName, State, _IsRetry = false),
+        fun(ok, NewState) ->
+            case F() of
+                {ok, _Pid} ->
+                    {ok, NewState};
+                {error, {already_started, _Pid}} ->
+                    {ok, NewState};
+                {error, Reason} ->
+                    {{error, Reason}, NewState}
+            end
+        end
+    ).
 
 %% Catches exit exceptions when making gen_server:call.
--spec safe_gen_call(pid() | atom(), Call, Timeout) -> Return
-        when Call    :: term(),
-             Timeout :: infinity | integer(),
-             Return  :: ok | {ok, term()} | {error, Reason},
-             Reason  :: client_down | {client_down, any()} | any().
+-spec safe_gen_call(pid() | atom(), Call, Timeout) -> Return when
+    Call :: term(),
+    Timeout :: infinity | integer(),
+    Return :: ok | {ok, term()} | {error, Reason},
+    Reason :: client_down | {client_down, any()} | any().
 safe_gen_call(Server, Call, Timeout) ->
-  try
-    gen_server:call(Server, Call, Timeout)
-  catch
-    exit : {noproc, _} ->
-      {error, client_down};
-    exit : {Reason, _} ->
-      {error, {client_down, Reason}}
-  end.
+    try
+        gen_server:call(Server, Call, Timeout)
+    catch
+        exit:{noproc, _} ->
+            {error, client_down};
+        exit:{Reason, _} ->
+            {error, {client_down, Reason}}
+    end.
 
 -spec kf(kpro:field_name(), kpro:struct()) -> kpro:field_value().
 kf(FieldName, Struct) -> kpro:find(FieldName, Struct).
diff --git a/src/brod_partitions_sync.erl b/src/brod_partitions_sync.erl
new file mode 100644
index 00000000..37a1c7da
--- /dev/null
+++ b/src/brod_partitions_sync.erl
@@ -0,0 +1,169 @@
+%%%
+%%%   Copyright (c) 2014-2021 Klarna Bank AB (publ)
+%%%
+%%%   Licensed under the Apache License, Version 2.0 (the "License");
+%%%   you may not use this file except in compliance with the License.
+%%%   You may obtain a copy of the License at
+%%%
+%%%       http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%%   Unless required by applicable law or agreed to in writing, software
+%%%   distributed under the License is distributed on an "AS IS" BASIS,
+%%%   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%%   See the License for the specific language governing permissions and
+%%%   limitations under the License.
+%%%
+
+%% @doc A `brod_partitions_sync' is a `gen_server' that is responsible for fetching
+%% the latest partition counts for a client and ensuring external changes to partitions
+%% are propogated to the clients and starts a producer for the partition if not present
+-module(brod_partitions_sync).
+-behaviour(gen_server).
+
+-export([
+    start_link/3
+]).
+
+-export([
+    code_change/3,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    init/1,
+    terminate/2
+]).
+
+-include("brod_int.hrl").
+
+-define(DEFAULT_SYNC_PARTITIONS_INTERVAL_SECONDS, 60).
+
+-record(state, {
+    client_id :: pid(),
+    producers_sup :: pid(),
+    interval :: non_neg_integer(),
+    config :: brod_client:config()
+}).
+
+-type state() :: #state{}.
+
+-spec start_link(pid(), pid(), brod_client:config()) ->
+    {ok, pid()} | {error, any()}.
+start_link(ClientId, ProducersSup, Config) ->
+    gen_server:start_link(?MODULE, {ClientId, ProducersSup, Config}, []).
+
+-spec init({pid(), pid(), brod_client:config()}) ->
+    {ok, state()}.
+init({ClientId, ProducersSup, Config}) ->
+    Interval = sync_partition_interval(Config),
+    schedule_sync(Interval),
+    State = #state{
+        client_id = ClientId,
+        producers_sup = ProducersSup,
+        interval = Interval,
+        config = Config
+    },
+
+    {ok, State}.
+
+%% @private
+handle_info(
+    sync,
+    #state{
+        client_id = Client,
+        config = Config,
+        producers_sup = Sup,
+        interval = Interval
+    } = State
+) ->
+    sync_partitions(Client, Sup, Config),
+    sync_client(Client),
+    schedule_sync(Interval),
+    {noreply, State};
+handle_info(_Info, #state{} = State) ->
+    {noreply, State}.
+
+%% @private
+handle_call(Call, _From, #state{} = State) ->
+    {reply, {error, {unsupported_call, Call}}, State}.
+
+%% @private
+handle_cast(_Cast, #state{} = State) ->
+    {noreply, State}.
+
+%% @private
+code_change(_OldVsn, #state{} = State, _Extra) ->
+    {ok, State}.
+
+%% @private
+terminate(_Reason, _State) ->
+    ok.
+
+%% @private
+sync_client(Client) ->
+    case brod_client:get_metadata_safe(Client, []) of
+        {ok, _} ->
+            ok;
+        {error, Error} ->
+            ?BROD_LOG_ERROR("Partitions Sync Client MetaData Error: ~p", [Error]),
+            ok
+    end.
+
+%% @private
+sync_partitions(Client, Sup, Config) ->
+    Producers = brod_supervisor3:which_children(Sup),
+    TopicsList = lists:map(fun({Topic, ProducerPid, _, _}) -> {Topic, ProducerPid} end, Producers),
+    TopicsMap = maps:from_list(TopicsList),
+    MetaData = get_metadata_for_topics(Client, maps:keys(TopicsMap)),
+    lists:foreach(
+        fun(#{name := Topic, partitions := Partitions}) ->
+            ProducerPid = maps:get(Topic, TopicsMap),
+
+            lists:foreach(
+                fun(#{partition_index := Partition}) ->
+                    sync_partition(ProducerPid, Client, Topic, Partition, Config)
+                end,
+                Partitions
+            )
+        end,
+        MetaData
+    ),
+    ok.
+
+%% @private
+schedule_sync(Interval) ->
+    erlang:send_after(Interval, self(), sync).
+
+%% @private
+sync_partition(Sup, Client, Topic, Partition, Config) ->
+    case brod_producers_sup:find_producer(Sup, Topic, Partition) of
+        {ok, Pid} ->
+            {ok, Pid};
+        {error, _} ->
+            brod_producers_sup:start_producer(Sup, Client, Topic, Partition, Config)
+    end.
+
+%% @private
+sync_partition_interval(Config) ->
+    T = proplists:get_value(
+        sync_partitions_interval_seconds, Config, ?DEFAULT_SYNC_PARTITIONS_INTERVAL_SECONDS
+    ),
+    timer:seconds(T).
+
+%% @private
+get_metadata_for_topics(_Client, []) ->
+    [];
+%% @private
+get_metadata_for_topics(Client, Topics) ->
+    case brod_client:get_bootstrap(Client) of
+        {ok, {Hosts, Conn}} ->
+            case brod_utils:get_metadata(Hosts, Topics, Conn) of
+                {ok, #{topics := MetaData}} ->
+                    MetaData;
+                {error, Error} ->
+                    ?BROD_LOG_ERROR("Partitions Sync MetaData Error: ~p", [Error]),
+                    []
+            end;
+        {error, Error} ->
+            ?BROD_LOG_ERROR("Partitions Sync Bootstrap Error: ~p", [Error]),
+            []
+    end.
diff --git a/src/brod_producers_sup.erl b/src/brod_producers_sup.erl
index 5625d304..b3bf1919 100644
--- a/src/brod_producers_sup.erl
+++ b/src/brod_producers_sup.erl
@@ -22,13 +22,16 @@
 -module(brod_producers_sup).
 -behaviour(brod_supervisor3).
 
--export([ init/1
-        , post_init/1
-        , start_link/0
-        , find_producer/3
-        , start_producer/4
-        , stop_producer/2
-        ]).
+-export([
+    init/1,
+    post_init/1,
+    start_link/0,
+    find_producer/3,
+    start_producer/4,
+    start_producer/5,
+    stop_producer/2,
+    producer_spec/4
+]).
 
 -include("brod_int.hrl").
 
@@ -51,107 +54,127 @@
 %% @end
 -spec start_link() -> {ok, pid()}.
 start_link() ->
-  brod_supervisor3:start_link(?MODULE, ?TOPICS_SUP).
+    brod_supervisor3:start_link(?MODULE, ?TOPICS_SUP).
 
 %% @doc Dynamically start a per-topic supervisor
 -spec start_producer(pid(), pid(), brod:topic(), brod:producer_config()) ->
-                        {ok, pid()} | {error, any()}.
+    {ok, pid()} | {error, any()}.
 start_producer(SupPid, ClientPid, TopicName, Config) ->
-  Spec = producers_sup_spec(ClientPid, TopicName, Config),
-  brod_supervisor3:start_child(SupPid, Spec).
+    Spec = producers_sup_spec(ClientPid, TopicName, Config),
+    brod_supervisor3:start_child(SupPid, Spec).
+
+%% @doc Dynamically start a per partition producer
+-spec start_producer(pid(), pid(), brod:topic(), non_neg_integer(), brod:producer_config()) ->
+    {ok, pid()} | {error, any()}.
+start_producer(SupPid, ClientPid, TopicName, Partition, Config) ->
+    Spec = producer_spec(ClientPid, TopicName, Partition, Config),
+    brod_supervisor3:start_child(SupPid, Spec).
 
 %% @doc Dynamically stop a per-topic supervisor
 -spec stop_producer(pid(), brod:topic()) -> ok | {}.
 stop_producer(SupPid, TopicName) ->
-  brod_supervisor3:terminate_child(SupPid, TopicName),
-  brod_supervisor3:delete_child(SupPid, TopicName).
+    brod_supervisor3:terminate_child(SupPid, TopicName),
+    brod_supervisor3:delete_child(SupPid, TopicName).
 
 %% @doc Find a brod_producer process pid running under ?PARTITIONS_SUP.
 -spec find_producer(pid(), brod:topic(), brod:partition()) ->
-                       {ok, pid()} | {error, Reason} when
-        Reason :: {producer_not_found, brod:topic()}
-                | {producer_not_found, brod:topic(), brod:partition()}
-                | {producer_down, any()}.
+    {ok, pid()} | {error, Reason}
+when
+    Reason ::
+        {producer_not_found, brod:topic()}
+        | {producer_not_found, brod:topic(), brod:partition()}
+        | {producer_down, any()}.
 find_producer(SupPid, Topic, Partition) ->
-  case brod_supervisor3:find_child(SupPid, Topic) of
-    [] ->
-      %% no such topic worker started,
-      %% check sys.config or brod:start_link_client args
-      {error, {producer_not_found, Topic}};
-    [PartitionsSupPid] ->
-      try
-        case brod_supervisor3:find_child(PartitionsSupPid, Partition) of
-          [] ->
-            %% no such partition?
-            {error, {producer_not_found, Topic, Partition}};
-          [Pid] ->
-            {ok, Pid}
-        end
-      catch exit : {Reason, _} ->
-        {error, {producer_down, Reason}}
-      end
-  end.
+    case brod_supervisor3:find_child(SupPid, Topic) of
+        [] ->
+            %% no such topic worker started,
+            %% check sys.config or brod:start_link_client args
+            {error, {producer_not_found, Topic}};
+        [PartitionsSupPid] ->
+            try
+                case brod_supervisor3:find_child(PartitionsSupPid, Partition) of
+                    [] ->
+                        %% no such partition?
+                        {error, {producer_not_found, Topic, Partition}};
+                    [Pid] ->
+                        {ok, Pid}
+                end
+            catch
+                exit:{Reason, _} ->
+                    {error, {producer_down, Reason}}
+            end
+    end.
 
 %% @doc brod_supervisor3 callback.
 init(?TOPICS_SUP) ->
-  {ok, {{one_for_one, 0, 1}, []}};
+    {ok, {{one_for_one, 0, 1}, []}};
 init({?PARTITIONS_SUP, _ClientPid, _Topic, _Config}) ->
-  post_init.
+    post_init.
 
 post_init({?PARTITIONS_SUP, ClientPid, Topic, Config}) ->
-  case brod_client:get_partitions_count(ClientPid, Topic) of
-    {ok, PartitionsCnt} ->
-      Children = [ producer_spec(ClientPid, Topic, Partition, Config)
-                 || Partition <- lists:seq(0, PartitionsCnt - 1) ],
-      %% Producer may crash in case of exception in case of network failure,
-      %% or error code received in produce response (e.g. leader transition)
-      %% In any case, restart right away will erry likely fail again.
-      %% Hence set MaxR=0 here to cool-down for a configurable N-seconds
-      %% before supervisor tries to restart it.
-      {ok, {{one_for_one, 0, 1}, Children}};
-    {error, Reason} ->
-      {error, Reason}
-  end.
+    case brod_client:get_partitions_count(ClientPid, Topic) of
+        {ok, PartitionsCnt} ->
+            Children = [
+                producer_spec(ClientPid, Topic, Partition, Config)
+             || Partition <- lists:seq(0, PartitionsCnt - 1)
+            ],
+            %% Producer may crash in case of exception in case of network failure,
+            %% or error code received in produce response (e.g. leader transition)
+            %% In any case, restart right away will erry likely fail again.
+            %% Hence set MaxR=0 here to cool-down for a configurable N-seconds
+            %% before supervisor tries to restart it.
+            {ok, {{one_for_one, 0, 1}, Children}};
+        {error, Reason} ->
+            {error, Reason}
+    end.
 
 producers_sup_spec(ClientPid, TopicName, Config0) ->
-  {Config, DelaySecs} =
-    take_delay_secs(Config0, topic_restart_delay_seconds,
-                    ?DEFAULT_PARTITIONS_SUP_RESTART_DELAY),
-  Args = [?MODULE, {?PARTITIONS_SUP, ClientPid, TopicName, Config}],
-  { _Id       = TopicName
-  , _Start    = {brod_supervisor3, start_link, Args}
-  , _Restart  = {permanent, DelaySecs}
-  , _Shutdown = infinity
-  , _Type     = supervisor
-  , _Module   = [?MODULE]
-  }.
+    {Config, DelaySecs} =
+        take_delay_secs(
+            Config0,
+            topic_restart_delay_seconds,
+            ?DEFAULT_PARTITIONS_SUP_RESTART_DELAY
+        ),
+    Args = [?MODULE, {?PARTITIONS_SUP, ClientPid, TopicName, Config}],
+    {
+        _Id = TopicName,
+        _Start = {brod_supervisor3, start_link, Args},
+        _Restart = {permanent, DelaySecs},
+        _Shutdown = infinity,
+        _Type = supervisor,
+        _Module = [?MODULE]
+    }.
 
 producer_spec(ClientPid, Topic, Partition, Config0) ->
-  {Config, DelaySecs} =
-    take_delay_secs(Config0, partition_restart_delay_seconds,
-                    ?DEFAULT_PRODUCER_RESTART_DELAY),
-  Args      = [ClientPid, Topic, Partition, Config],
-  { _Id       = Partition
-  , _Start    = {brod_producer, start_link, Args}
-  , _Restart  = {permanent, DelaySecs}
-  , _Shutdown = 5000
-  , _Type     = worker
-  , _Module   = [brod_producer]
-  }.
+    {Config, DelaySecs} =
+        take_delay_secs(
+            Config0,
+            partition_restart_delay_seconds,
+            ?DEFAULT_PRODUCER_RESTART_DELAY
+        ),
+    Args = [ClientPid, Topic, Partition, Config],
+    {
+        _Id = Partition,
+        _Start = {brod_producer, start_link, Args},
+        _Restart = {permanent, DelaySecs},
+        _Shutdown = 5000,
+        _Type = worker,
+        _Module = [brod_producer]
+    }.
 
 %%%_* Internal Functions =======================================================
 
 -spec take_delay_secs(brod:producer_config(), atom(), integer()) ->
-        {brod:producer_config(), integer()}.
+    {brod:producer_config(), integer()}.
 take_delay_secs(Config, Name, DefaultValue) ->
-  Secs =
-    case proplists:get_value(Name, Config) of
-      N when is_integer(N) andalso N >= ?MIN_SUPERVISOR3_DELAY_SECS ->
-        N;
-      _ ->
-        DefaultValue
-    end,
-  {proplists:delete(Name, Config), Secs}.
+    Secs =
+        case proplists:get_value(Name, Config) of
+            N when is_integer(N) andalso N >= ?MIN_SUPERVISOR3_DELAY_SECS ->
+                N;
+            _ ->
+                DefaultValue
+        end,
+    {proplists:delete(Name, Config), Secs}.
 
 %%%_* Emacs ====================================================================
 %%% Local Variables:
diff --git a/test/brod_client_SUITE.erl b/test/brod_client_SUITE.erl
index d907b391..2b7bc000 100644
--- a/test/brod_client_SUITE.erl
+++ b/test/brod_client_SUITE.erl
@@ -29,7 +29,7 @@
 -export([ auth/6 ]).
 
 %% Test cases
--export([ t_optional_metadata_syncing/1
+-export([ t_optional_partitions_syncing/1
         , t_skip_unreachable_endpoint/1
         , t_no_reachable_endpoint/1
         , t_call_bad_client_id/1
@@ -80,7 +80,7 @@
         , consumers_sup        :: pid()
         , config               :: list()
         , workers_tab          :: ets:tab()
-        , sync_ref             :: reference()
+        , partitions_sync      :: reference()
         }).
 
 %%%_* ct callbacks =============================================================
@@ -129,16 +129,20 @@ all() ->
 
 %%%_* Test functions ===========================================================
 
-t_optional_metadata_syncing(Config) when is_list(Config) ->
+t_optional_partitions_syncing(Config) when is_list(Config) ->
   Client0 = has_sync,
-  Config0 = [{sync_metadata, true}],
-  {ok, #state{ sync_ref = HasRef }} = brod_client:init({?HOSTS, Client0, Config0}),
-  ?assertNot(HasRef =:= undefined),
+  Config0 = [{sync_partitions, true}],
+  ok = start_client(?HOSTS, Client0, Config0),
+  #state{ partitions_sync = Pid0 } = sys:get_state(Client0),
+  ?assert(is_process_alive(Pid0)),
+  ok = brod:stop_client(Client0),
 
-  Config1 = [{sync_metadata, false}],
+  Config1 = [{sync_partitions, false}],
   Client1 = no_sync,
-  {ok, #state{ sync_ref = NoRef }} = brod_client:init({?HOSTS, Client1, Config1}),
-  ?assertMatch(undefined, NoRef).
+  ok = start_client(?HOSTS, Client1, Config1),
+  #state{ partitions_sync = Pid1 } = sys:get_state(Client1),
+  ?assertMatch(undefined, Pid1),
+  ok = brod:stop_client(Client1).
 
 t_get_partitions_count_safe(Config) when is_list(Config) ->
   Client = ?FUNCTION_NAME,
@@ -151,7 +155,6 @@ t_get_partitions_count_safe(Config) when is_list(Config) ->
   ?assertMatch({error, unknown_topic_or_partition}, Res2),
   ok = brod:stop_client(Client).
 
-
 t_get_partitions_count_configure_cache_ttl(Config) when is_list(Config) ->
   Client = ?FUNCTION_NAME,
   ClientConfig = [{unknown_topic_cache_ttl, 100}],

From 646aeb24a49d01212e11b780354093cfa81d3eca Mon Sep 17 00:00:00 2001
From: Christopher Kempton <kempt09@gmail.com>
Date: Tue, 30 Sep 2025 14:40:08 -0400
Subject: [PATCH 06/15] Update src/brod_partitions_sync.erl

Co-authored-by: zmstone <zmstone@gmail.com>
---
 src/brod_partitions_sync.erl | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/brod_partitions_sync.erl b/src/brod_partitions_sync.erl
index 37a1c7da..8e74d7d4 100644
--- a/src/brod_partitions_sync.erl
+++ b/src/brod_partitions_sync.erl
@@ -1,6 +1,3 @@
-%%%
-%%%   Copyright (c) 2014-2021 Klarna Bank AB (publ)
-%%%
 %%%   Licensed under the Apache License, Version 2.0 (the "License");
 %%%   you may not use this file except in compliance with the License.
 %%%   You may obtain a copy of the License at

From a9e1e9dd73f4f10f4614bbe4ee388be265b43c1f Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 19:35:39 +0000
Subject: [PATCH 07/15] update with master

---
 CHANGELOG.md                 |   3 +
 src/brod.erl                 |  41 +++++++++
 src/brod_client.erl          |  20 ++++-
 src/brod_kafka_apis.erl      |  23 +++--
 src/brod_kafka_request.erl   |  12 +++
 src/brod_partitions_sync.erl | 166 +++++++++++++++++++++++++++++++++++
 src/brod_utils.erl           |  24 +++++
 test/brod_SUITE.erl          |  17 +++-
 test/brod_client_SUITE.erl   |  29 +++++-
 9 files changed, 326 insertions(+), 9 deletions(-)
 create mode 100644 src/brod_partitions_sync.erl

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d697493c..7e562a58 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Changelog
+- 4.5.0
+  - Expose `create_partitions` from the underlying kafka_protocol
+  - Allow partitions to automatically have producers started for newly discovered partitions.
 
 - 4.4.6
   - Upgrade to `kafka_protocol-4.2.8` for dependency (`crc32cer-1.0.4`) to fix its link error.
diff --git a/src/brod.erl b/src/brod.erl
index 415ad28c..d49dba5f 100644
--- a/src/brod.erl
+++ b/src/brod.erl
@@ -96,6 +96,8 @@
 %% Topic APIs
 -export([ create_topics/3
         , create_topics/4
+        , create_partitions/3
+        , create_partitions/4
         , delete_topics/3
         , delete_topics/4
         ]).
@@ -190,6 +192,7 @@
 -type endpoint() :: {hostname(), portnum()}.
 -type topic() :: kpro:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: kpro:partition().
 -type topic_partition() :: {topic(), partition()}.
 -type offset() :: kpro:offset(). %% Physical offset (an integer)
@@ -1049,6 +1052,44 @@ create_topics(Hosts, TopicConfigs, RequestConfigs) ->
 create_topics(Hosts, TopicConfigs, RequestConfigs, Options) ->
   brod_utils:create_topics(Hosts, TopicConfigs, RequestConfigs, Options).
 
+%% @equiv create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, [])
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()}) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs) ->
+  brod_utils:create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs).
+
+%% @doc Create partitions(s) in kafka.
+%%  <ul>
+%%    <li>`topic'
+%%      The topic name.
+%%    </li>
+%%
+%%    <li>`new_partitions'
+%%      The `count` of how many partitions will exist for the topic. current + desired
+%%      The number of `assignment` should be equal to the number of new partitions.
+%%      Each list for assignment specify the prefferred broker ids to assign
+%%    </li>
+%%
+%% Example:
+%% ```
+%% > TopicPartitionConfigs = [
+%%       #{
+%%         topic: <<"my_topic">>,
+%%          new_partitions: #{
+%%            count: 6,
+%%            assignment: [[1,2], [2,3], [3,1]]
+%%        }
+%%      }
+%%   ].
+%% > brod:create_partitions([{"localhost", 9092}], TopicPartitionConfigs, #{timeout => 1000}, []).
+%% ok
+%% '''
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()},
+                    conn_config()) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, Options) ->
+  brod_utils:create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, Options).
+
 %% @equiv delete_topics(Hosts, Topics, Timeout, [])
 -spec delete_topics([endpoint()], [topic()], pos_integer()) ->
         ok | {error, any()}.
diff --git a/src/brod_client.erl b/src/brod_client.erl
index a03c24d0..b5b54597 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -73,6 +73,7 @@
 -define(DEFAULT_RECONNECT_COOL_DOWN_SECONDS, 1).
 -define(DEFAULT_GET_METADATA_TIMEOUT_SECONDS, 5).
 -define(DEFAULT_UNKNOWN_TOPIC_CACHE_TTL, 120000).
+-define(DEFAULT_SYNC_METADATA_INTERVAL_SECONDS, 60).
 
 %% ClientId as ets table name.
 -define(ETS(ClientId), ClientId).
@@ -131,6 +132,7 @@
         , consumers_sup        :: ?undef | pid()
         , config               :: ?undef | config()
         , workers_tab          :: ?undef | ets:tab()
+        , partitions_sync      :: ?undef | pid()
         }).
 
 -type state() :: #state{}.
@@ -363,13 +365,20 @@ handle_continue(init, State0) ->
   State1 = ensure_metadata_connection(State0),
   {ok, ProducersSupPid} = brod_producers_sup:start_link(),
   {ok, ConsumersSupPid} = brod_consumers_sup:start_link(),
-  State = State1#state{ bootstrap_endpoints = Endpoints
+  State2 = State1#state{ bootstrap_endpoints = Endpoints
                       , producers_sup       = ProducersSupPid
                       , consumers_sup       = ConsumersSupPid
                       },
+  State = State2#state{partitions_sync = maybe_start_partitions_sync(State2)},
   {noreply, State}.
 
 %% @private
+handle_info({'EXIT', Pid, Reason}, #state{ client_id        = ClientId
+                                         , partitions_sync  = Pid
+                                        } = State) ->
+    ?BROD_LOG_ERROR("client ~p partitions sync down~nReason: ~p", [ClientId, Pid, Reason]),
+    NewState = State#state{partitions_sync = maybe_start_partitions_sync(State)},
+    {noreply, NewState};
 handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                                          , producers_sup = Pid
                                          } = State) ->
@@ -737,6 +746,15 @@ ensure_binary(ClientId) when is_atom(ClientId) ->
 ensure_binary(ClientId) when is_binary(ClientId) ->
   ClientId.
 
+maybe_start_partitions_sync(#state{client_id = Client, producers_sup = ProducersSup, config = Config}) ->
+  case config(sync_partitions, Config, false) of
+    true ->
+      {ok, Pid} = brod_partitions_sync:start_link(Client, ProducersSup, Config),
+      Pid;
+    false ->
+      undefined
+  end.
+
 -spec maybe_connect(state(), endpoint()) ->
         {Result, state()} when Result :: {ok, pid()} | {error, any()}.
 maybe_connect(#state{} = State, Endpoint) ->
diff --git a/src/brod_kafka_apis.erl b/src/brod_kafka_apis.erl
index 78a529fc..b076a257 100644
--- a/src/brod_kafka_apis.erl
+++ b/src/brod_kafka_apis.erl
@@ -157,11 +157,24 @@ supported_versions() ->
 
 %% Do not change range without verification.
 supported_versions(API) ->
-  try
-    maps:get(API, supported_versions())
-  catch
-    _ : _ ->
-      erlang:error({unsupported_api, API})
+  case API of
+    produce           -> {0, 7};
+    fetch             -> {0, 10};
+    list_offsets      -> {0, 2};
+    metadata          -> {0, 2};
+    offset_commit     -> {2, 2};
+    offset_fetch      -> {1, 2};
+    find_coordinator  -> {0, 0};
+    join_group        -> {0, 1};
+    heartbeat         -> {0, 0};
+    leave_group       -> {0, 0};
+    sync_group        -> {0, 0};
+    describe_groups   -> {0, 0};
+    list_groups       -> {0, 0};
+    create_topics     -> {0, 0};
+    create_partitions -> {0, 1};
+    delete_topics     -> {0, 0};
+    _                 -> erlang:error({unsupported_api, API})
   end.
 
 monitor_connection(Conn) ->
diff --git a/src/brod_kafka_request.erl b/src/brod_kafka_request.erl
index b2403a01..1adfb6fb 100644
--- a/src/brod_kafka_request.erl
+++ b/src/brod_kafka_request.erl
@@ -18,6 +18,7 @@
 -module(brod_kafka_request).
 
 -export([ create_topics/3
+        , create_partitions/3
         , delete_topics/3
         , fetch/8
         , list_groups/1
@@ -36,6 +37,7 @@
 -type vsn() :: brod_kafka_apis:vsn().
 -type topic() :: brod:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: brod:partition().
 -type offset() :: brod:offset().
 -type conn() :: kpro:connection().
@@ -65,6 +67,16 @@ create_topics(Connection, TopicConfigs, RequestConfigs)
 create_topics(Vsn, TopicConfigs, RequestConfigs) ->
   kpro_req_lib:create_topics(Vsn, TopicConfigs, RequestConfigs).
 
+%% @doc Make a create_partitions request.
+-spec create_partitions(vsn() | conn(), [topic_partition_config()], #{timeout => kpro:int32(),
+                    validate_only => boolean()}) -> kpro:req().
+create_partitions(Connection, TopicPartitionConfigs, RequestConfigs)
+              when is_pid(Connection) ->
+  Vsn = brod_kafka_apis:pick_version(Connection, create_partitions),
+  create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs);
+create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs) ->
+  kpro_req_lib:create_partitions(Vsn, TopicPartitionConfigs, RequestConfigs).
+
 %% @doc Make a delete_topics request.
 -spec delete_topics(vsn() | conn(), [topic()], pos_integer()) -> kpro:req().
 delete_topics(Connection, Topics, Timeout) when is_pid(Connection) ->
diff --git a/src/brod_partitions_sync.erl b/src/brod_partitions_sync.erl
new file mode 100644
index 00000000..c46c5cc6
--- /dev/null
+++ b/src/brod_partitions_sync.erl
@@ -0,0 +1,166 @@
+%%%   Licensed under the Apache License, Version 2.0 (the "License");
+%%%   you may not use this file except in compliance with the License.
+%%%   You may obtain a copy of the License at
+%%%
+%%%       http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%%   Unless required by applicable law or agreed to in writing, software
+%%%   distributed under the License is distributed on an "AS IS" BASIS,
+%%%   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%%   See the License for the specific language governing permissions and
+%%%   limitations under the License.
+%%%
+
+%% @doc A `brod_partitions_sync' is a `gen_server' that is responsible for fetching
+%% the latest partition counts for a client and ensuring external changes to partitions
+%% are propogated to the clients and starts a producer for the partition if not present
+-module(brod_partitions_sync).
+-behaviour(gen_server).
+
+-export([
+    start_link/3
+]).
+
+-export([
+    code_change/3,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    init/1,
+    terminate/2
+]).
+
+-include("brod_int.hrl").
+
+-define(DEFAULT_SYNC_PARTITIONS_INTERVAL_SECONDS, 60).
+
+-record(state, {
+    client_id :: pid(),
+    producers_sup :: pid(),
+    interval :: non_neg_integer(),
+    config :: brod_client:config()
+}).
+
+-type state() :: #state{}.
+
+-spec start_link(pid(), pid(), brod_client:config()) ->
+    {ok, pid()} | {error, any()}.
+start_link(ClientId, ProducersSup, Config) ->
+    gen_server:start_link(?MODULE, {ClientId, ProducersSup, Config}, []).
+
+-spec init({pid(), pid(), brod_client:config()}) ->
+    {ok, state()}.
+init({ClientId, ProducersSup, Config}) ->
+    Interval = sync_partition_interval(Config),
+    schedule_sync(Interval),
+    State = #state{
+        client_id = ClientId,
+        producers_sup = ProducersSup,
+        interval = Interval,
+        config = Config
+    },
+
+    {ok, State}.
+
+%% @private
+handle_info(
+    sync,
+    #state{
+        client_id = Client,
+        config = Config,
+        producers_sup = Sup,
+        interval = Interval
+    } = State
+) ->
+    sync_partitions(Client, Sup, Config),
+    sync_client(Client),
+    schedule_sync(Interval),
+    {noreply, State};
+handle_info(_Info, #state{} = State) ->
+    {noreply, State}.
+
+%% @private
+handle_call(Call, _From, #state{} = State) ->
+    {reply, {error, {unsupported_call, Call}}, State}.
+
+%% @private
+handle_cast(_Cast, #state{} = State) ->
+    {noreply, State}.
+
+%% @private
+code_change(_OldVsn, #state{} = State, _Extra) ->
+    {ok, State}.
+
+%% @private
+terminate(_Reason, _State) ->
+    ok.
+
+%% @private
+sync_client(Client) ->
+    case brod_client:get_metadata_safe(Client, []) of
+        {ok, _} ->
+            ok;
+        {error, Error} ->
+            ?BROD_LOG_ERROR("Partitions Sync Client MetaData Error: ~p", [Error]),
+            ok
+    end.
+
+%% @private
+sync_partitions(Client, Sup, Config) ->
+    Producers = brod_supervisor3:which_children(Sup),
+    TopicsList = lists:map(fun({Topic, ProducerPid, _, _}) -> {Topic, ProducerPid} end, Producers),
+    TopicsMap = maps:from_list(TopicsList),
+    MetaData = get_metadata_for_topics(Client, maps:keys(TopicsMap)),
+    lists:foreach(
+        fun(#{name := Topic, partitions := Partitions}) ->
+            ProducerPid = maps:get(Topic, TopicsMap),
+
+            lists:foreach(
+                fun(#{partition_index := Partition}) ->
+                    sync_partition(ProducerPid, Client, Topic, Partition, Config)
+                end,
+                Partitions
+            )
+        end,
+        MetaData
+    ),
+    ok.
+
+%% @private
+schedule_sync(Interval) ->
+    erlang:send_after(Interval, self(), sync).
+
+%% @private
+sync_partition(Sup, Client, Topic, Partition, Config) ->
+    case brod_producers_sup:find_producer(Sup, Topic, Partition) of
+        {ok, Pid} ->
+            {ok, Pid};
+        {error, _} ->
+            brod_producers_sup:start_producer(Sup, Client, Topic, Partition, Config)
+    end.
+
+%% @private
+sync_partition_interval(Config) ->
+    T = proplists:get_value(
+        sync_partitions_interval_seconds, Config, ?DEFAULT_SYNC_PARTITIONS_INTERVAL_SECONDS
+    ),
+    timer:seconds(T).
+
+%% @private
+get_metadata_for_topics(_Client, []) ->
+    [];
+%% @private
+get_metadata_for_topics(Client, Topics) ->
+    case brod_client:get_bootstrap(Client) of
+        {ok, {Hosts, Conn}} ->
+            case brod_utils:get_metadata(Hosts, Topics, Conn) of
+                {ok, #{topics := MetaData}} ->
+                    MetaData;
+                {error, Error} ->
+                    ?BROD_LOG_ERROR("Partitions Sync MetaData Error: ~p", [Error]),
+                    []
+            end;
+        {error, Error} ->
+            ?BROD_LOG_ERROR("Partitions Sync Bootstrap Error: ~p", [Error]),
+            []
+    end.
\ No newline at end of file
diff --git a/src/brod_utils.erl b/src/brod_utils.erl
index e6525f01..e3c54b9a 100644
--- a/src/brod_utils.erl
+++ b/src/brod_utils.erl
@@ -26,6 +26,8 @@
         , describe_groups/3
         , create_topics/3
         , create_topics/4
+        , create_partitions/3
+        , create_partitions/4
         , delete_topics/3
         , delete_topics/4
         , epoch_ms/0
@@ -73,6 +75,7 @@
 -type conn_config() :: brod:conn_config().
 -type topic() :: brod:topic().
 -type topic_config() :: kpro:struct().
+-type topic_partition_config() :: kpro:struct().
 -type partition() :: brod:partition().
 -type offset() :: brod:offset().
 -type endpoint() :: brod:endpoint().
@@ -103,6 +106,27 @@ create_topics(Hosts, TopicConfigs, RequestConfigs, ConnCfg) ->
                   Pid, TopicConfigs, RequestConfigs),
                 request_sync(Pid, Request)
             end).
+
+%% @equiv create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, [])
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()}) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs) ->
+  create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, _ConnCfg = []).
+
+%% @doc Try to connect to the controller node using the given
+%% connection options and create the given partitions with configs
+-spec create_partitions([endpoint()], [topic_partition_config()], #{timeout => kpro:int32()},
+                    conn_config()) ->
+        ok | {error, any()}.
+create_partitions(Hosts, TopicPartitionConfigs, RequestConfigs, ConnCfg) ->
+  KproOpts = kpro_connection_options(ConnCfg),
+  with_conn(kpro:connect_controller(Hosts, nolink(ConnCfg), KproOpts),
+            fun(Pid) ->
+                Request = brod_kafka_request:create_partitions(
+                  Pid, TopicPartitionConfigs, RequestConfigs),
+                request_sync(Pid, Request)
+            end).
+
 %% @equiv delete_topics(Hosts, Topics, Timeout, [])
 -spec delete_topics([endpoint()], [topic()], pos_integer()) ->
         ok | {error, any()}.
diff --git a/test/brod_SUITE.erl b/test/brod_SUITE.erl
index 806d97da..1f32727c 100644
--- a/test/brod_SUITE.erl
+++ b/test/brod_SUITE.erl
@@ -25,7 +25,7 @@
         ]).
 
 %% Test cases
--export([ t_create_delete_topics/1
+-export([ t_create_update_delete_topics/1
         , t_delete_topics_not_found/1
         ]).
 
@@ -60,7 +60,7 @@ all() -> [F || {F, _A} <- module_info(exports),
 
 %%%_* Test functions ===========================================================
 
-t_create_delete_topics(Config) when is_list(Config) ->
+t_create_update_delete_topics(Config) when is_list(Config) ->
   Topic = iolist_to_binary(["test-topic-", integer_to_list(erlang:system_time())]),
   TopicConfig = [
     #{
@@ -71,9 +71,22 @@ t_create_delete_topics(Config) when is_list(Config) ->
       name => Topic
     }
   ],
+  TopicPartitionConfig = [
+    #{
+      topic => Topic,
+      new_partitions => #{
+        count => 2,
+        assignment => [[0]]
+      }
+    }
+  ],
   try
     ?assertEqual(ok,
       brod:create_topics(?HOSTS, TopicConfig, #{timeout => ?TIMEOUT},
+        #{connect_timeout => ?TIMEOUT})),
+
+    ?assertEqual(ok,
+      brod:create_partitions(?HOSTS, TopicPartitionConfig, #{timeout => ?TIMEOUT},
         #{connect_timeout => ?TIMEOUT}))
   after
     ?assertEqual(ok, brod:delete_topics(?HOSTS, [Topic], ?TIMEOUT,
diff --git a/test/brod_client_SUITE.erl b/test/brod_client_SUITE.erl
index af3ef6f3..5314b15d 100644
--- a/test/brod_client_SUITE.erl
+++ b/test/brod_client_SUITE.erl
@@ -29,7 +29,8 @@
 -export([ auth/6 ]).
 
 %% Test cases
--export([ t_skip_unreachable_endpoint/1
+-export([ t_optional_partitions_syncing/1
+        , t_skip_unreachable_endpoint/1
         , t_no_reachable_endpoint/1
         , t_call_bad_client_id/1
         , t_metadata_connection_restart/1
@@ -69,6 +70,18 @@
           end
         end()).
 
+-record(state,
+        { client_id            :: pid()
+        , bootstrap_endpoints  :: [brod:endpoint()]
+        , meta_conn            :: kpro:connection()
+        , payload_conns = []   :: list()
+        , producers_sup        :: pid()
+        , consumers_sup        :: pid()
+        , config               :: list()
+        , workers_tab          :: ets:tab()
+        , partitions_sync      :: reference()
+        }).
+
 %%%_* ct callbacks =============================================================
 
 suite() -> [{timetrap, {seconds, 30}}].
@@ -114,6 +127,20 @@ all() ->
 
 
 %%%_* Test functions ===========================================================
+t_optional_partitions_syncing(Config) when is_list(Config) ->
+  Client0 = has_sync,
+  Config0 = [{sync_partitions, true}],
+  ok = start_client(?HOSTS, Client0, Config0),
+  #state{ partitions_sync = Pid0 } = sys:get_state(Client0),
+  ?assert(is_process_alive(Pid0)),
+  ok = brod:stop_client(Client0),
+
+  Config1 = [{sync_partitions, false}],
+  Client1 = no_sync,
+  ok = start_client(?HOSTS, Client1, Config1),
+  #state{ partitions_sync = Pid1 } = sys:get_state(Client1),
+  ?assertMatch(undefined, Pid1),
+  ok = brod:stop_client(Client1).
 
 t_get_partitions_count_safe(Config) when is_list(Config) ->
   Client = ?FUNCTION_NAME,

From a85a76390f92a85e1fe412d7e7e662775b300127 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 19:43:18 +0000
Subject: [PATCH 08/15] handle conflict on supported versions

---
 src/brod_kafka_apis.erl | 24 ++++++------------------
 1 file changed, 6 insertions(+), 18 deletions(-)

diff --git a/src/brod_kafka_apis.erl b/src/brod_kafka_apis.erl
index b076a257..5e647dfb 100644
--- a/src/brod_kafka_apis.erl
+++ b/src/brod_kafka_apis.erl
@@ -152,29 +152,17 @@ supported_versions() ->
    , describe_groups => {0, 5}
    , list_groups => {0, 3}
    , create_topics => {0, 4}
+   , create_partitions => {0, 1}
    , delete_topics => {0, 4}
    }.
 
 %% Do not change range without verification.
 supported_versions(API) ->
-  case API of
-    produce           -> {0, 7};
-    fetch             -> {0, 10};
-    list_offsets      -> {0, 2};
-    metadata          -> {0, 2};
-    offset_commit     -> {2, 2};
-    offset_fetch      -> {1, 2};
-    find_coordinator  -> {0, 0};
-    join_group        -> {0, 1};
-    heartbeat         -> {0, 0};
-    leave_group       -> {0, 0};
-    sync_group        -> {0, 0};
-    describe_groups   -> {0, 0};
-    list_groups       -> {0, 0};
-    create_topics     -> {0, 0};
-    create_partitions -> {0, 1};
-    delete_topics     -> {0, 0};
-    _                 -> erlang:error({unsupported_api, API})
+  try
+    maps:get(API, supported_versions())
+  catch
+    _ : _ ->
+      erlang:error({unsupported_api, API})
   end.
 
 monitor_connection(Conn) ->

From ae0b067986ac8eb2135f89084c76b459c7f2d9e7 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 19:54:10 +0000
Subject: [PATCH 09/15] passing lint

---
 src/brod_client.erl        | 15 ---------------
 src/brod_producers_sup.erl |  7 -------
 2 files changed, 22 deletions(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index f71a9597..a61bf281 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -923,20 +923,6 @@ is_cooled_down(Ts, #state{config = Config}) ->
     Diff >= Threshold.
 
 %% call this function after fetched metadata for all topics
-<<<<<<< HEAD
-%% to cache the not-found status of a given topic
-maybe_cache_unknown_topic_partition(Ets, Topic, TopicMetadataArray, UnknownTopicCacheTtl) ->
-    case find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic) of
-        {error, unknown_topic_or_partition} = Err ->
-            _ = ets:insert(Ets, {
-                ?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}
-            }),
-            ok;
-        _ ->
-            %% do nothing when ok or any other error
-            ok
-    end.
-=======
 %% to cache the not-found status of a given topics
 maybe_cache_unknown_topic_partition(_Ets, [], _TopicMetadata, _TopicCacheTTL) -> ok;
 maybe_cache_unknown_topic_partition(Ets, [Topic | Rest], TopicMetadata, TopicCacheTTL) ->
@@ -948,7 +934,6 @@ maybe_cache_unknown_topic_partition(Ets, [Topic | Rest], TopicMetadata, TopicCac
       ok
   end,
   maybe_cache_unknown_topic_partition(Ets, Rest, TopicMetadata, TopicCacheTTL).
->>>>>>> a85a76390f92a85e1fe412d7e7e662775b300127
 
 -spec update_partitions_count_cache(ets:tab(), [kpro:struct()], non_neg_integer()) -> ok.
 update_partitions_count_cache(_Ets, [], _UnknownTopicCacheTtl) ->
diff --git a/src/brod_producers_sup.erl b/src/brod_producers_sup.erl
index 391283ce..c242ff64 100644
--- a/src/brod_producers_sup.erl
+++ b/src/brod_producers_sup.erl
@@ -63,13 +63,6 @@ start_producer(SupPid, ClientPid, TopicName, Config) ->
     Spec = producers_sup_spec(ClientPid, TopicName, Config),
     brod_supervisor3:start_child(SupPid, Spec).
 
-%% @doc Dynamically start a per partition producer
--spec start_producer(pid(), pid(), brod:topic(), non_neg_integer(), brod:producer_config()) ->
-    {ok, pid()} | {error, any()}.
-start_producer(SupPid, ClientPid, TopicName, Partition, Config) ->
-    Spec = producer_spec(ClientPid, TopicName, Partition, Config),
-    brod_supervisor3:start_child(SupPid, Spec).
-
 %% @doc Dynamically start a partition producer
 -spec start_producer(pid(), pid(), brod:topic(), brod:partition(), brod:producer_config()) ->
   {ok, pid()} | {error, any()}.

From cf3865efea1505d35298011fdf2765c44af43bcb Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 19:58:12 +0000
Subject: [PATCH 10/15] pass dialyzer

---
 src/brod_partitions_sync.erl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/brod_partitions_sync.erl b/src/brod_partitions_sync.erl
index 8e74d7d4..be76eecc 100644
--- a/src/brod_partitions_sync.erl
+++ b/src/brod_partitions_sync.erl
@@ -43,7 +43,7 @@
 
 -type state() :: #state{}.
 
--spec start_link(pid(), pid(), brod_client:config()) ->
+-spec start_link(atom(), pid(), brod_client:config()) ->
     {ok, pid()} | {error, any()}.
 start_link(ClientId, ProducersSup, Config) ->
     gen_server:start_link(?MODULE, {ClientId, ProducersSup, Config}, []).

From 19d9d5ed884a047a6b46a5746573138232105e8f Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 20:13:21 +0000
Subject: [PATCH 11/15] completely revert client to current state

---
 src/brod_client.erl          | 1162 +++++++++++++++-------------------
 src/brod_partitions_sync.erl |    2 +-
 2 files changed, 529 insertions(+), 635 deletions(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index a61bf281..95ef2ce1 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -25,38 +25,37 @@
 -module(brod_client).
 -behaviour(gen_server).
 
--export([
-    get_consumer/3,
-    get_connection/3,
-    get_group_coordinator/2,
-    get_transactional_coordinator/2,
-    get_leader_connection/3,
-    get_bootstrap/1,
-    get_metadata/2,
-    get_metadata_safe/2,
-    get_partitions_count/2,
-    get_partitions_count_safe/2,
-    get_producer/3,
-    register_consumer/3,
-    register_producer/3,
-    deregister_consumer/3,
-    deregister_producer/3,
-    start_link/3,
-    start_producer/3,
-    start_consumer/3,
-    stop/1,
-    stop_producer/2,
-    stop_consumer/2
-]).
+-export([ get_consumer/3
+        , get_connection/3
+        , get_group_coordinator/2
+        , get_transactional_coordinator/2
+        , get_leader_connection/3
+        , get_bootstrap/1
+        , get_metadata/2
+        , get_metadata_safe/2
+        , get_partitions_count/2
+        , get_partitions_count_safe/2
+        , get_producer/3
+        , register_consumer/3
+        , register_producer/3
+        , deregister_consumer/3
+        , deregister_producer/3
+        , start_link/3
+        , start_producer/3
+        , start_consumer/3
+        , stop/1
+        , stop_producer/2
+        , stop_consumer/2
+        ]).
 
 %% Private export
--export([
-    find_producer/3,
-    find_consumer/3
-]).
+-export([ find_producer/3
+        , find_consumer/3
+        ]).
 
 %% Test export
--export([lookup_partitions_count_cache/2]).
+-export([ lookup_partitions_count_cache/2
+        ]).
 
 -export([ code_change/3
         , handle_call/3
@@ -74,21 +73,19 @@
 -define(DEFAULT_RECONNECT_COOL_DOWN_SECONDS, 1).
 -define(DEFAULT_GET_METADATA_TIMEOUT_SECONDS, 5).
 -define(DEFAULT_UNKNOWN_TOPIC_CACHE_TTL, 120000).
--define(DEFAULT_SYNC_METADATA_INTERVAL_SECONDS, 60).
 
 %% ClientId as ets table name.
 -define(ETS(ClientId), ClientId).
 -define(PRODUCER_KEY(Topic, Partition),
-    {producer, Topic, Partition}
-).
+        {producer, Topic, Partition}).
 -define(CONSUMER_KEY(Topic, Partition),
-    {consumer, Topic, Partition}
-).
+        {consumer, Topic, Partition}).
 -define(TOPIC_METADATA_KEY(Topic),
-    {topics, Topic}
-).
--define(PRODUCER(Topic, Partition, Pid), {?PRODUCER_KEY(Topic, Partition), Pid}).
--define(CONSUMER(Topic, Partition, Pid), {?CONSUMER_KEY(Topic, Partition), Pid}).
+        {topics, Topic}).
+-define(PRODUCER(Topic, Partition, Pid),
+        {?PRODUCER_KEY(Topic, Partition), Pid}).
+-define(CONSUMER(Topic, Partition, Pid),
+        {?CONSUMER_KEY(Topic, Partition), Pid}).
 
 -type endpoint() :: brod:endpoint().
 -type client() :: brod:client().
@@ -99,35 +96,31 @@
 -type group_id() :: brod:group_id().
 -type transactional_id() :: brod:transactional_id().
 
--type partition_worker_key() ::
-    ?PRODUCER_KEY(topic(), partition())
-    | ?CONSUMER_KEY(topic(), partition()).
+-type partition_worker_key() :: ?PRODUCER_KEY(topic(), partition())
+                              | ?CONSUMER_KEY(topic(), partition()).
 
--type get_producer_error() ::
-    client_down
-    | {client_down, any()}
-    | {producer_down, any()}
-    | {producer_not_found, topic()}
-    | {producer_not_found, topic(), partition()}.
+-type get_producer_error() :: client_down
+                            | {client_down, any()}
+                            | {producer_down, any()}
+                            | {producer_not_found, topic()}
+                            | {producer_not_found, topic(), partition()}.
 
--type get_consumer_error() ::
-    client_down
-    | {client_down, any()}
-    | {consumer_down, any()}
-    | {consumer_not_found, topic()}
-    | {consumer_not_found, topic(), partition()}.
+-type get_consumer_error() :: client_down
+                            | {client_down, any()}
+                            | {consumer_down, any()}
+                            | {consumer_not_found, topic()}
+                            | {consumer_not_found, topic(), partition()}.
 
--type get_worker_error() ::
-    get_producer_error()
-    | get_consumer_error().
+-type get_worker_error() :: get_producer_error()
+                          | get_consumer_error().
 
 -define(dead_since(TS, REASON), {dead_since, TS, REASON}).
 -type connection() :: kpro:connection().
 -type dead_conn() :: ?dead_since(erlang:timestamp(), any()).
--record(conn, {
-    endpoint :: endpoint(),
-    pid :: connection() | dead_conn()
-}).
+-record(conn,
+       { endpoint :: endpoint()
+       , pid :: connection() | dead_conn()
+       }).
 -type conn_state() :: #conn{}.
 -record(state,
         { client_id            :: client_id()
@@ -138,7 +131,6 @@
         , consumers_sup        :: ?undef | pid()
         , config               :: ?undef | config()
         , workers_tab          :: ?undef | ets:tab()
-        , partitions_sync      :: ?undef | pid()
         }).
 
 -type state() :: #state{}.
@@ -146,85 +138,83 @@
 %%%_* APIs =====================================================================
 
 -spec start_link([endpoint()], client_id(), config()) ->
-    {ok, pid()} | {error, any()}.
+        {ok, pid()} | {error, any()}.
 start_link(BootstrapEndpoints, ClientId, Config) when is_atom(ClientId) ->
-    Args = {BootstrapEndpoints, ClientId, Config},
-    gen_server:start_link({local, ClientId}, ?MODULE, Args, []).
+  Args = {BootstrapEndpoints, ClientId, Config},
+  gen_server:start_link({local, ClientId}, ?MODULE, Args, []).
 
 -spec stop(client()) -> ok.
 stop(Client) ->
-    Mref = erlang:monitor(process, Client),
-    _ = safe_gen_call(Client, stop, infinity),
-    receive
-        {'DOWN', Mref, process, _, _Reason} ->
-            ok
-    end.
+  Mref = erlang:monitor(process, Client),
+  _ = safe_gen_call(Client, stop, infinity),
+  receive
+    {'DOWN', Mref, process, _, _Reason} ->
+      ok
+  end.
 
 %% @doc Get producer of the given topic-partition.
 %%
 %% The producer is started if auto_start_producers is
 %% enabled in client config.
 -spec get_producer(client(), topic(), partition()) ->
-    {ok, pid()} | {error, get_producer_error()}.
+        {ok, pid()} | {error, get_producer_error()}.
 get_producer(Client, Topic, Partition) ->
-    case get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) of
-        {ok, Pid} ->
-            {ok, Pid};
-        {error, {producer_not_found, Topic}} = Error ->
-            maybe_start_producer(Client, Topic, Partition, Error);
-        Error ->
-            Error
-    end.
+  case get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) of
+    {ok, Pid} ->
+      {ok, Pid};
+    {error, {producer_not_found, Topic}} = Error ->
+      maybe_start_producer(Client, Topic, Partition, Error);
+    Error ->
+      Error
+  end.
 
 %% @doc Get consumer of the given topic-partition.
 -spec get_consumer(client(), topic(), partition()) ->
-    {ok, pid()} | {error, get_consumer_error()}.
+        {ok, pid()} | {error, get_consumer_error()}.
 get_consumer(Client, Topic, Partition) ->
-    get_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)).
+  get_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)).
 
 %% @doc Dynamically start a per-topic producer.
 %%
 %% Return ok if the producer is already started.
 -spec start_producer(client(), topic(), brod:producer_config()) ->
-    ok | {error, any()}.
+        ok | {error, any()}.
 start_producer(Client, TopicName, ProducerConfig) ->
-    case get_producer(Client, TopicName, _Partition = 0) of
-        {ok, _Pid} ->
-            %% already started
-            ok;
-        {error, {producer_not_found, TopicName}} ->
-            Call = {start_producer, TopicName, ProducerConfig},
-            safe_gen_call(Client, Call, infinity);
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  case get_producer(Client, TopicName, _Partition = 0) of
+    {ok, _Pid} ->
+      ok; %% already started
+    {error, {producer_not_found, TopicName}} ->
+      Call = {start_producer, TopicName, ProducerConfig},
+      safe_gen_call(Client, Call, infinity);
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 %% @doc Stop all partition producers of the given topic.
 -spec stop_producer(client(), topic()) -> ok | {error, any()}.
 stop_producer(Client, TopicName) ->
-    safe_gen_call(Client, {stop_producer, TopicName}, infinity).
+  safe_gen_call(Client, {stop_producer, TopicName}, infinity).
 
 %% @doc Dynamically start a topic consumer.
 %%
 %% Returns ok if the consumer is already started.
 -spec start_consumer(client(), topic(), brod:consumer_config()) ->
-    ok | {error, any()}.
+                        ok | {error, any()}.
 start_consumer(Client, TopicName, ConsumerConfig) ->
-    case get_consumer(Client, TopicName, _Partition = 0) of
-        {ok, _Pid} ->
-            %% already started
-            ok;
-        {error, {consumer_not_found, TopicName}} ->
-            Call = {start_consumer, TopicName, ConsumerConfig},
-            safe_gen_call(Client, Call, infinity);
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  case get_consumer(Client, TopicName, _Partition = 0) of
+    {ok, _Pid} ->
+      ok; %% already started
+    {error, {consumer_not_found, TopicName}} ->
+      Call = {start_consumer, TopicName, ConsumerConfig},
+      safe_gen_call(Client, Call, infinity);
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 %% @doc Stop all partition consumers of the given topic.
 -spec stop_consumer(client(), topic()) -> ok | {error, any()}.
 stop_consumer(Client, TopicName) ->
-    safe_gen_call(Client, {stop_consumer, TopicName}, infinity).
+  safe_gen_call(Client, {stop_consumer, TopicName}, infinity).
 
 %% @doc Get the connection to kafka broker which is a leader for given
 %% Topic-Partition.
@@ -234,13 +224,13 @@ stop_consumer(Client, TopicName) ->
 %% If the old connection was dead less than a configurable N seconds ago,
 %% `{error, LastReason}' is returned.
 -spec get_leader_connection(client(), topic(), partition()) ->
-    {ok, pid()} | {error, any()}.
+        {ok, pid()} | {error, any()}.
 get_leader_connection(Client, Topic, Partition) ->
-    safe_gen_call(Client, {get_leader_connection, Topic, Partition}, infinity).
+  safe_gen_call(Client, {get_leader_connection, Topic, Partition}, infinity).
 
 -spec get_bootstrap(client()) -> {ok, brod:bootstrap()} | {error, any()}.
 get_bootstrap(Client) ->
-    safe_gen_call(Client, get_bootstrap, infinity).
+  safe_gen_call(Client, get_bootstrap, infinity).
 
 %% @doc Get connection to a kafka broker.
 %%
@@ -249,9 +239,9 @@ get_bootstrap(Client) ->
 %% If the old connection was dead less than a configurable N seconds ago,
 %% `{error, LastReason}' is returned.
 -spec get_connection(client(), brod:hostname(), brod:portnum()) ->
-    {ok, pid()} | {error, any()}.
+        {ok, pid()} | {error, any()}.
 get_connection(Client, Host, Port) ->
-    safe_gen_call(Client, {get_connection, Host, Port}, infinity).
+  safe_gen_call(Client, {get_connection, Host, Port}, infinity).
 
 %% @doc Get topic metadata, if topic is `undefined', will fetch ALL metadata.
 -spec get_metadata(client(), all | ?undef | topic() | [topic()]) ->
@@ -276,40 +266,41 @@ get_metadata_safe(Client, Topic) ->
 %% @doc Get number of partitions for a given topic.
 -spec get_partitions_count(client(), topic()) -> {ok, pos_integer()} | {error, any()}.
 get_partitions_count(Client, Topic) ->
-    %% Set default allow_topic_auto_creation to true does not imply the topic is always
-    %% auto-created. Kafka can have auto-creation disabled, in which case this option has no effect.
-    get_partitions_count(Client, Topic, #{allow_topic_auto_creation => true}).
+  %% Set default allow_topic_auto_creation to true does not imply the topic is always
+  %% auto-created. Kafka can have auto-creation disabled, in which case this option has no effect.
+  get_partitions_count(Client, Topic, #{allow_topic_auto_creation => true}).
 
 get_partitions_count(Client, Topic, Opts) when is_atom(Client) ->
-    %% Ets =:= ClientId
-    do_get_partitions_count(Client, Client, Topic, Opts);
+  %% Ets =:= ClientId
+  do_get_partitions_count(Client, Client, Topic, Opts);
 get_partitions_count(Client, Topic, Opts) when is_pid(Client) ->
-    case safe_gen_call(Client, get_workers_table, infinity) of
-        {ok, Ets} -> do_get_partitions_count(Client, Ets, Topic, Opts);
-        {error, Reason} -> {error, Reason}
-    end.
+  case safe_gen_call(Client, get_workers_table, infinity) of
+    {ok, Ets}       -> do_get_partitions_count(Client, Ets, Topic, Opts);
+    {error, Reason} -> {error, Reason}
+  end.
 
 %% @doc Get number of partitions for an existing topic.
 %% Ensured not to auto create a topic even when Kafka is configured
 %% with topic auto creation enabled.
 -spec get_partitions_count_safe(client(), topic()) ->
-    {ok, pos_integer()} | {error, any()}.
+        {ok, pos_integer()} | {error, any()}.
 get_partitions_count_safe(Client, Topic) ->
     get_partitions_count(Client, Topic, #{allow_topic_auto_creation => false}).
 
 %% @doc Get broker endpoint and connection config for
 %% connecting a group coordinator.
 -spec get_group_coordinator(client(), group_id()) ->
-    {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
+        {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
 get_group_coordinator(Client, GroupId) ->
-    safe_gen_call(Client, {get_group_coordinator, GroupId}, infinity).
+  safe_gen_call(Client, {get_group_coordinator, GroupId}, infinity).
 
 %% @doc Get broker endpoint and connection config for
 %% connecting a transactional coordinator.
 -spec get_transactional_coordinator(client(), transactional_id()) ->
-    {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
+        {ok, {endpoint(), brod:conn_config()}} | {error, any()}.
 get_transactional_coordinator(Client, TransactionId) ->
-    safe_gen_call(Client, {get_transactional_coordinator, TransactionId}, infinity).
+  safe_gen_call(Client, {get_transactional_coordinator, TransactionId}, infinity).
+
 
 %% @doc Register self() as a partition producer.
 %%
@@ -318,9 +309,9 @@ get_transactional_coordinator(Client, TransactionId) ->
 %% produce requests to the producer process directly.
 -spec register_producer(client(), topic(), partition()) -> ok.
 register_producer(Client, Topic, Partition) ->
-    Producer = self(),
-    Key = ?PRODUCER_KEY(Topic, Partition),
-    gen_server:cast(Client, {register, Key, Producer}).
+  Producer = self(),
+  Key = ?PRODUCER_KEY(Topic, Partition),
+  gen_server:cast(Client, {register, Key, Producer}).
 
 %% @doc De-register the producer for a partition.
 %%
@@ -329,8 +320,8 @@ register_producer(Client, Topic, Partition) ->
 %% stopped producers and allow later restart.
 -spec deregister_producer(client(), topic(), partition()) -> ok.
 deregister_producer(Client, Topic, Partition) ->
-    Key = ?PRODUCER_KEY(Topic, Partition),
-    gen_server:cast(Client, {deregister, Key}).
+  Key = ?PRODUCER_KEY(Topic, Partition),
+  gen_server:cast(Client, {deregister, Key}).
 
 %% @doc Register self() as a partition consumer.
 %%
@@ -339,9 +330,9 @@ deregister_producer(Client, Topic, Partition) ->
 %% calls to the process directly.
 -spec register_consumer(client(), topic(), partition()) -> ok.
 register_consumer(Client, Topic, Partition) ->
-    Consumer = self(),
-    Key = ?CONSUMER_KEY(Topic, Partition),
-    gen_server:cast(Client, {register, Key, Consumer}).
+  Consumer = self(),
+  Key = ?CONSUMER_KEY(Topic, Partition),
+  gen_server:cast(Client, {register, Key, Consumer}).
 
 %% @doc De-register the consumer for a partition.
 %%
@@ -350,8 +341,8 @@ register_consumer(Client, Topic, Partition) ->
 %% allow later restart.
 -spec deregister_consumer(client(), topic(), partition()) -> ok.
 deregister_consumer(Client, Topic, Partition) ->
-    Key = ?CONSUMER_KEY(Topic, Partition),
-    gen_server:cast(Client, {deregister, Key}).
+  Key = ?CONSUMER_KEY(Topic, Partition),
+  gen_server:cast(Client, {deregister, Key}).
 
 %%%_* gen_server callbacks =====================================================
 
@@ -372,20 +363,13 @@ handle_continue(init, State0) ->
   State1 = ensure_metadata_connection(State0),
   {ok, ProducersSupPid} = brod_producers_sup:start_link(),
   {ok, ConsumersSupPid} = brod_consumers_sup:start_link(),
-  State2 = State1#state{ bootstrap_endpoints = Endpoints
+  State = State1#state{ bootstrap_endpoints = Endpoints
                       , producers_sup       = ProducersSupPid
                       , consumers_sup       = ConsumersSupPid
                       },
-  State = State2#state{partitions_sync = maybe_start_partitions_sync(State2)},
   {noreply, State}.
 
 %% @private
-handle_info({'EXIT', Pid, Reason}, #state{ client_id        = ClientId
-                                         , partitions_sync  = Pid
-                                        } = State) ->
-    ?BROD_LOG_ERROR("client ~p partitions sync down~nReason: ~p", [ClientId, Pid, Reason]),
-    NewState = State#state{partitions_sync = maybe_start_partitions_sync(State)},
-    {noreply, NewState};
 handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                                          , producers_sup = Pid
                                          } = State) ->
@@ -399,228 +383,215 @@ handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                   [ClientId, Pid, Reason]),
   {stop, {consumers_sup_down, Reason}, State};
 handle_info({'EXIT', Pid, Reason}, State) ->
-    NewState = handle_connection_down(State, Pid, Reason),
-    {noreply, NewState};
+  NewState = handle_connection_down(State, Pid, Reason),
+  {noreply, NewState};
 handle_info(Info, State) ->
-    ?BROD_LOG_WARNING(
-        "~p [~p] ~p got unexpected info: ~p",
-        [?MODULE, self(), State#state.client_id, Info]
-    ),
-    {noreply, State}.
+  ?BROD_LOG_WARNING("~p [~p] ~p got unexpected info: ~p",
+                    [?MODULE, self(), State#state.client_id, Info]),
+  {noreply, State}.
 
 %% @private
 handle_call({stop_producer, Topic}, _From, State) ->
-    ok = brod_producers_sup:stop_producer(State#state.producers_sup, Topic),
-    {reply, ok, State};
+  ok = brod_producers_sup:stop_producer(State#state.producers_sup, Topic),
+  {reply, ok, State};
 handle_call({stop_consumer, Topic}, _From, State) ->
-    Reply = brod_consumers_sup:stop_consumer(State#state.consumers_sup, Topic),
-    {reply, Reply, State};
+  Reply = brod_consumers_sup:stop_consumer(State#state.consumers_sup, Topic),
+  {reply, Reply, State};
 handle_call({get_leader_connection, Topic, Partition}, _From, State) ->
-    {Result, NewState} = do_get_leader_connection(State, Topic, Partition),
-    {reply, Result, NewState};
+  {Result, NewState} = do_get_leader_connection(State, Topic, Partition),
+  {reply, Result, NewState};
 handle_call(get_bootstrap, _From, State) ->
-    #state{bootstrap_endpoints = Endpoints} = State,
-    ConnConfig = conn_config(State),
-    {reply, {ok, {Endpoints, ConnConfig}}, State};
+  #state{bootstrap_endpoints = Endpoints} = State,
+  ConnConfig = conn_config(State),
+  {reply, {ok, {Endpoints, ConnConfig}}, State};
 handle_call({get_connection, Host, Port}, _From, State) ->
-    {Result, NewState} = maybe_connect(State, {Host, Port}),
-    {reply, Result, NewState};
+  {Result, NewState} = maybe_connect(State, {Host, Port}),
+  {reply, Result, NewState};
 handle_call({get_group_coordinator, GroupId}, _From, State) ->
-    {Result, NewState} = do_get_group_coordinator(State, GroupId),
-    {reply, Result, NewState};
+  {Result, NewState} = do_get_group_coordinator(State, GroupId),
+  {reply, Result, NewState};
 handle_call({get_transactional_coordinator, TransactionId}, _From, State) ->
-    {Result, NewState} = do_get_transactional_coordinator(State, TransactionId),
-    {reply, Result, NewState};
+  {Result, NewState} = do_get_transactional_coordinator(State, TransactionId),
+  {reply, Result, NewState};
 handle_call({start_producer, TopicName, ProducerConfig}, _From, State) ->
-    {Reply, NewState} = do_start_producer(TopicName, ProducerConfig, State),
-    {reply, Reply, NewState};
+  {Reply, NewState} = do_start_producer(TopicName, ProducerConfig, State),
+  {reply, Reply, NewState};
 handle_call({start_consumer, TopicName, ConsumerConfig}, _From, State) ->
-    {Reply, NewState} = do_start_consumer(TopicName, ConsumerConfig, State),
-    {reply, Reply, NewState};
+  {Reply, NewState} = do_start_consumer(TopicName, ConsumerConfig, State),
+  {reply, Reply, NewState};
 handle_call({auto_start_producer, Topic}, _From, State) ->
-    Config = State#state.config,
-    case config(auto_start_producers, Config, false) of
-        true ->
-            ProducerConfig = config(default_producer_config, Config, []),
-            {Reply, NewState} = do_start_producer(Topic, ProducerConfig, State),
-            {reply, Reply, NewState};
-        false ->
-            {reply, {error, disabled}, State}
-    end;
+  Config = State#state.config,
+  case config(auto_start_producers, Config, false) of
+    true ->
+      ProducerConfig = config(default_producer_config, Config, []),
+      {Reply, NewState} = do_start_producer(Topic, ProducerConfig, State),
+      {reply, Reply, NewState};
+    false ->
+      {reply, {error, disabled}, State}
+  end;
 handle_call(get_workers_table, _From, State) ->
-    {reply, {ok, State#state.workers_tab}, State};
+  {reply, {ok, State#state.workers_tab}, State};
 handle_call(get_producers_sup_pid, _From, State) ->
-    {reply, {ok, State#state.producers_sup}, State};
+  {reply, {ok, State#state.producers_sup}, State};
 handle_call(get_consumers_sup_pid, _From, State) ->
   {reply, {ok, State#state.consumers_sup}, State};
 handle_call({get_metadata, Topics}, _From, State) ->
   {Result, NewState} = do_get_metadata(Topics, State),
   {reply, Result, NewState};
 handle_call(stop, _From, State) ->
-    {stop, normal, ok, State};
+  {stop, normal, ok, State};
 handle_call(Call, _From, State) ->
-    {reply, {error, {unknown_call, Call}}, State}.
+  {reply, {error, {unknown_call, Call}}, State}.
 
 %% @private
 handle_cast({register, Key, Pid}, #state{workers_tab = Tab} = State) ->
-    ets:insert(Tab, {Key, Pid}),
-    {noreply, State};
+  ets:insert(Tab, {Key, Pid}),
+  {noreply, State};
 handle_cast({deregister, Key}, #state{workers_tab = Tab} = State) ->
-    ets:delete(Tab, Key),
-    {noreply, State};
+  ets:delete(Tab, Key),
+  {noreply, State};
 handle_cast(Cast, State) ->
-    ?BROD_LOG_WARNING(
-        "~p [~p] ~p got unexpected cast: ~p",
-        [?MODULE, self(), State#state.client_id, Cast]
-    ),
-    {noreply, State}.
+  ?BROD_LOG_WARNING("~p [~p] ~p got unexpected cast: ~p",
+                    [?MODULE, self(), State#state.client_id, Cast]),
+  {noreply, State}.
 
 %% @private
 code_change(_OldVsn, State, _Extra) ->
-    {ok, State}.
+  {ok, State}.
 
 %% @private
-terminate(Reason, #state{
-    client_id = ClientId,
-    meta_conn = MetaConn,
-    payload_conns = PayloadConns,
-    producers_sup = ProducersSup,
-    consumers_sup = ConsumersSup
-}) ->
-    case brod_utils:is_normal_reason(Reason) of
-        true ->
-            ok;
-        false ->
-            ?BROD_LOG_WARNING(
-                "~p [~p] ~p is terminating\nreason: ~p~n",
-                [?MODULE, self(), ClientId, Reason]
-            )
-    end,
-    %% stop producers and consumers first because they are monitoring connections
-    shutdown_pid(ProducersSup),
-    shutdown_pid(ConsumersSup),
-    Shutdown = fun(#conn{pid = Pid}) -> shutdown_pid(Pid) end,
-    lists:foreach(Shutdown, PayloadConns),
-    shutdown_pid(MetaConn).
+terminate(Reason, #state{ client_id     = ClientId
+                        , meta_conn     = MetaConn
+                        , payload_conns = PayloadConns
+                        , producers_sup = ProducersSup
+                        , consumers_sup = ConsumersSup
+                        }) ->
+  case brod_utils:is_normal_reason(Reason) of
+    true ->
+      ok;
+    false ->
+      ?BROD_LOG_WARNING("~p [~p] ~p is terminating\nreason: ~p~n",
+                        [?MODULE, self(), ClientId, Reason])
+  end,
+  %% stop producers and consumers first because they are monitoring connections
+  shutdown_pid(ProducersSup),
+  shutdown_pid(ConsumersSup),
+  Shutdown = fun(#conn{pid = Pid}) -> shutdown_pid(Pid) end,
+  lists:foreach(Shutdown, PayloadConns),
+  shutdown_pid(MetaConn).
 
 %%%_* Internal Functions =======================================================
 
 shutdown_pid(Pid) when is_pid(Pid) ->
-    exit(Pid, shutdown),
-    ok;
+  exit(Pid, shutdown),
+  ok;
 shutdown_pid(_) ->
-    ok.
+  ok.
 
 -spec get_partition_worker(client(), partition_worker_key()) ->
-    {ok, pid()} | {error, get_worker_error()}.
+        {ok, pid()} | {error, get_worker_error()}.
 get_partition_worker(ClientPid, Key) when is_pid(ClientPid) ->
-    case erlang:process_info(ClientPid, registered_name) of
-        {registered_name, ClientId} ->
-            get_partition_worker(ClientId, Key);
-        _ ->
-            %% This is a client process started without registered name
-            %% have to call the process to get the producer/consumer worker
-            %% process registration table.
-            get_partition_worker_with_ets(ClientPid, Key)
-    end;
+  case erlang:process_info(ClientPid, registered_name) of
+    {registered_name, ClientId} -> get_partition_worker(ClientId, Key);
+
+    _ ->
+      %% This is a client process started without registered name
+      %% have to call the process to get the producer/consumer worker
+      %% process registration table.
+      get_partition_worker_with_ets(ClientPid, Key)
+  end;
+
 get_partition_worker(ClientId, Key) when is_atom(ClientId) ->
-    case lookup_partition_worker(ClientId, ?ETS(ClientId), Key) of
-        {ok, Pid} ->
-            %% This is an attempt to help with a race condition
-            %% between ets lookups and what is being supervised.
-            %% If the worker process is returned form ets,
-            %% but it is not alive then there must be
-            %% an in-flight worker deregistration request.
-            case is_pid(Pid) andalso is_process_alive(Pid) of
-                true -> {ok, Pid};
-                false -> get_partition_worker_with_ets(ClientId, Key)
-            end;
-        Other ->
-            Other
-    end.
+  case lookup_partition_worker(ClientId, ?ETS(ClientId), Key) of
+    {ok, Pid} ->
+      %% This is an attempt to help with a race condition
+      %% between ets lookups and what is being supervised.
+      %% If the worker process is returned form ets,
+      %% but it is not alive then there must be
+      %% an in-flight worker deregistration request.
+      case is_pid(Pid) andalso is_process_alive(Pid) of
+        true -> {ok, Pid};
+        false -> get_partition_worker_with_ets(ClientId, Key)
+      end;
+    Other -> Other
+  end.
 
 -spec get_partition_worker_with_ets(client(), partition_worker_key()) ->
-    {ok, pid()} | {error, get_worker_error()}.
+  {ok, pid()} | {error, get_worker_error()}.
 get_partition_worker_with_ets(Client, Key) ->
-    case safe_gen_call(Client, get_workers_table, infinity) of
-        {ok, Ets} -> lookup_partition_worker(Client, Ets, Key);
-        {error, Reason} -> {error, Reason}
-    end.
+  case safe_gen_call(Client, get_workers_table, infinity) of
+    {ok, Ets} -> lookup_partition_worker(Client, Ets, Key);
+    {error, Reason} -> {error, Reason}
+  end.
 
 -spec lookup_partition_worker(client(), ets:tab(), partition_worker_key()) ->
-    {ok, pid()} | {error, get_worker_error()}.
+        {ok, pid()} | { error, get_worker_error()}.
 lookup_partition_worker(Client, Ets, Key) ->
-    try ets:lookup(Ets, Key) of
-        [] ->
-            %% not yet registered, 2 possible reasons:
-            %% 1. caller is too fast, producers/consumers are starting up
-            %%    make a synced call all the way down the supervision tree
-            %%    to the partition producer sup should resolve the race
-            %% 2. bad argument, no such worker started, supervisors should know
-            find_partition_worker(Client, Key);
-        [?PRODUCER(_Topic, _Partition, Pid)] ->
-            {ok, Pid};
-        [?CONSUMER(_Topic, _Partition, Pid)] ->
-            {ok, Pid}
-    catch
-        error:badarg ->
-            {error, client_down}
-    end.
+  try ets:lookup(Ets, Key) of
+    [] ->
+      %% not yet registered, 2 possible reasons:
+      %% 1. caller is too fast, producers/consumers are starting up
+      %%    make a synced call all the way down the supervision tree
+      %%    to the partition producer sup should resolve the race
+      %% 2. bad argument, no such worker started, supervisors should know
+      find_partition_worker(Client, Key);
+    [?PRODUCER(_Topic, _Partition, Pid)] ->
+      {ok, Pid};
+    [?CONSUMER(_Topic, _Partition, Pid)] ->
+      {ok, Pid}
+  catch
+    error : badarg ->
+      {error, client_down}
+  end.
 
 -spec find_partition_worker(client(), partition_worker_key()) ->
-    {ok, pid()} | {error, get_worker_error()}.
+        {ok, pid()} | {error, get_worker_error()}.
 find_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition)) ->
-    find_producer(Client, Topic, Partition);
+  find_producer(Client, Topic, Partition);
 find_partition_worker(Client, ?CONSUMER_KEY(Topic, Partition)) ->
-    find_consumer(Client, Topic, Partition).
+  find_consumer(Client, Topic, Partition).
 
 -spec find_producer(client(), topic(), partition()) ->
-    {ok, pid()} | {error, get_producer_error()}.
+        {ok, pid()} | {error, get_producer_error()}.
 find_producer(Client, Topic, Partition) ->
-    case safe_gen_call(Client, get_producers_sup_pid, infinity) of
-        {ok, SupPid} ->
-            brod_producers_sup:find_producer(SupPid, Topic, Partition);
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  case safe_gen_call(Client, get_producers_sup_pid, infinity) of
+    {ok, SupPid} ->
+      brod_producers_sup:find_producer(SupPid, Topic, Partition);
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 -spec find_consumer(client(), topic(), partition()) ->
-    {ok, pid()} | {error, get_consumer_error()}.
+        {ok, pid()} | {error, get_consumer_error()}.
 find_consumer(Client, Topic, Partition) ->
-    case safe_gen_call(Client, get_consumers_sup_pid, infinity) of
-        {ok, SupPid} ->
-            brod_consumers_sup:find_consumer(SupPid, Topic, Partition);
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  case safe_gen_call(Client, get_consumers_sup_pid, infinity) of
+    {ok, SupPid} ->
+      brod_consumers_sup:find_consumer(SupPid, Topic, Partition);
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 -spec validate_topic_existence(topic(), state(), boolean()) ->
-    {Result, state()}
-when
-    Result :: ok | {error, any()}.
+        {Result, state()} when Result :: ok | {error, any()}.
 validate_topic_existence(Topic, #state{workers_tab = Ets} = State, IsRetry) ->
-    case lookup_partitions_count_cache(Ets, Topic) of
-        {ok, _Count} ->
-            {ok, State};
-        {error, Reason} ->
-            {{error, Reason}, State};
-        false when IsRetry ->
-            {{error, ?unknown_topic_or_partition}, State};
-        false ->
-            %% Try fetch metadata (and populate partition count cache)
-            %% Then validate topic existence again.
-            with_ok(
-                do_get_metadata_safe(Topic, State),
-                fun(_, S) -> validate_topic_existence(Topic, S, true) end
-            )
-    end.
+  case lookup_partitions_count_cache(Ets, Topic) of
+    {ok, _Count} ->
+      {ok, State};
+    {error, Reason} ->
+      {{error, Reason}, State};
+    false when IsRetry ->
+      {{error, ?unknown_topic_or_partition}, State};
+    false ->
+      %% Try fetch metadata (and populate partition count cache)
+      %% Then validate topic existence again.
+      with_ok(do_get_metadata_safe(Topic, State),
+              fun(_, S) -> validate_topic_existence(Topic, S, true) end)
+  end.
 
 %% Continue with {{ok, Result}, NewState}
 %% return whatever error immediately.
 -spec with_ok(Result, fun((_, state()) -> Result)) ->
-    Result
-when
-    Result :: {ok | {ok, term()} | {error, any()}, state()}.
+        Result when Result :: {ok | {ok, term()} | {error, any()}, state()}.
 with_ok({ok, State}, Continue) -> Continue(ok, State);
 with_ok({{ok, OK}, State}, Continue) -> Continue(OK, State);
 with_ok({{error, _}, #state{}} = Return, _Continue) -> Return.
@@ -629,8 +600,8 @@ with_ok({{error, _}, #state{}} = Return, _Continue) -> Return.
 %% do not try to fetch metadata per topic name, fetch all topics instead.
 %% As sending metadata request with topic name will cause an auto creation
 %% of the topic if auto.create.topics.enable is enabled in broker config.
--spec do_get_metadata_safe(topic(), state()) -> {Result, state()} when
-    Result :: {ok, kpro:struct()} | {error, any()}.
+-spec do_get_metadata_safe(topic(), state()) -> {Result, state()}
+        when Result :: {ok, kpro:struct()} | {error, any()}.
 do_get_metadata_safe(Topic0, #state{config = Config} = State) ->
   Topic =
     case config(allow_topic_auto_creation, Config, true) of
@@ -685,187 +656,145 @@ do_get_metadata(FetchMetadataFor, Topics,
   end.
 
 %% Ensure there is at least one metadata connection
-ensure_metadata_connection(
-    #state{
-        bootstrap_endpoints = Endpoints,
-        meta_conn = ?undef
-    } = State
-) ->
-    ConnConfig = conn_config(State),
-    Pid =
-        case kpro:connect_any(Endpoints, ConnConfig) of
-            {ok, PidX} -> PidX;
-            {error, Reason} -> erlang:exit(Reason)
+ensure_metadata_connection(#state{ bootstrap_endpoints = Endpoints
+                                 , meta_conn = ?undef
+                                 } = State) ->
+  ConnConfig = conn_config(State),
+  Pid = case kpro:connect_any(Endpoints, ConnConfig) of
+          {ok, PidX} -> PidX;
+          {error, Reason} -> erlang:exit(Reason)
         end,
-    State#state{meta_conn = Pid};
+  State#state{meta_conn = Pid};
 ensure_metadata_connection(State) ->
-    State.
+  State.
 
 %% must be called after ensure_metadata_connection
 get_metadata_connection(#state{meta_conn = Conn}) -> Conn.
 
 do_get_leader_connection(State0, Topic, Partition) ->
-    State = ensure_metadata_connection(State0),
-    MetaConn = get_metadata_connection(State),
-    Timeout = timeout(State),
-    case kpro:discover_partition_leader(MetaConn, Topic, Partition, Timeout) of
-        {ok, Endpoint} -> maybe_connect(State, Endpoint);
-        {error, Reason} -> {{error, Reason}, State}
-    end.
+  State = ensure_metadata_connection(State0),
+  MetaConn = get_metadata_connection(State),
+  Timeout = timeout(State),
+  case kpro:discover_partition_leader(MetaConn, Topic, Partition, Timeout) of
+    {ok, Endpoint} -> maybe_connect(State, Endpoint);
+    {error, Reason} -> {{error, Reason}, State}
+  end.
 
 -spec do_get_group_coordinator(state(), group_id()) ->
-    {Result, state()}
-when
-    Result :: {ok, connection()} | {error, any()}.
+        {Result, state()} when Result :: {ok, connection()} | {error, any()}.
 do_get_group_coordinator(State0, GroupId) ->
-    State = ensure_metadata_connection(State0),
-    MetaConn = get_metadata_connection(State),
-    Timeout = timeout(State),
-    case kpro:discover_coordinator(MetaConn, group, GroupId, Timeout) of
-        {ok, Endpoint} ->
-            {{ok, {Endpoint, conn_config(State)}}, State};
-        {error, Reason} ->
-            {{error, Reason}, State}
-    end.
+  State = ensure_metadata_connection(State0),
+  MetaConn = get_metadata_connection(State),
+  Timeout = timeout(State),
+  case kpro:discover_coordinator(MetaConn, group, GroupId, Timeout) of
+    {ok, Endpoint} ->
+      {{ok, {Endpoint, conn_config(State)}}, State};
+    {error, Reason} ->
+      {{error, Reason}, State}
+  end.
 
 -spec do_get_transactional_coordinator(state(), transactional_id()) ->
-    {Result, state()}
-when
-    Result :: {ok, connection()} | {error, any()}.
+        {Result, state()} when Result :: {ok, connection()} | {error, any()}.
 do_get_transactional_coordinator(State0, TransactionId) ->
-    State = ensure_metadata_connection(State0),
-    MetaConn = get_metadata_connection(State),
-    Timeout = timeout(State),
-    case kpro:discover_coordinator(MetaConn, txn, TransactionId, Timeout) of
-        {ok, Endpoint} ->
-            {{ok, {Endpoint, conn_config(State)}}, State};
-        {error, Reason} ->
-            {{error, Reason}, State}
-    end.
+  State = ensure_metadata_connection(State0),
+  MetaConn = get_metadata_connection(State),
+  Timeout = timeout(State),
+  case kpro:discover_coordinator(MetaConn, txn, TransactionId, Timeout) of
+    {ok, Endpoint} ->
+      {{ok, {Endpoint, conn_config(State)}}, State};
+    {error, Reason} ->
+      {{error, Reason}, State}
+  end.
 
 timeout(#state{config = Config}) ->
-    timeout(Config);
+  timeout(Config);
 timeout(Config) ->
-    T = config(
-        get_metadata_timeout_seconds,
-        Config,
-        ?DEFAULT_GET_METADATA_TIMEOUT_SECONDS
-    ),
-    timer:seconds(T).
+  T = config(get_metadata_timeout_seconds, Config,
+             ?DEFAULT_GET_METADATA_TIMEOUT_SECONDS),
+  timer:seconds(T).
 
 config(Key, Config, Default) ->
-    proplists:get_value(Key, Config, Default).
+  proplists:get_value(Key, Config, Default).
 
 conn_config(#state{client_id = ClientId, config = Config}) ->
-    Cfg = conn_config(Config, kpro_connection:all_cfg_keys(), []),
-    maps:from_list([{client_id, ensure_binary(ClientId)} | Cfg]).
+  Cfg = conn_config(Config, kpro_connection:all_cfg_keys(), []),
+  maps:from_list([{client_id, ensure_binary(ClientId)} | Cfg]).
 
-conn_config([], _ConnCfgKeys, Acc) ->
-    Acc;
+conn_config([], _ConnCfgKeys, Acc) -> Acc;
 conn_config([{K, V} | Rest], ConnCfgKeys, Acc) ->
-    NewAcc =
-        case lists:member(K, ConnCfgKeys) of
-            true -> [{K, V} | Acc];
-            false -> Acc
-        end,
-    conn_config(Rest, ConnCfgKeys, NewAcc);
+  NewAcc =
+    case lists:member(K, ConnCfgKeys) of
+      true -> [{K, V} | Acc];
+      false -> Acc
+    end,
+  conn_config(Rest, ConnCfgKeys, NewAcc);
 conn_config([K | Rest], ConnCfgKeys, Acc) when is_atom(K) ->
-    %% translate proplist boolean mark to tuple
-    conn_config([{K, true} | Rest], ConnCfgKeys, Acc).
+  %% translate proplist boolean mark to tuple
+  conn_config([{K, true} | Rest], ConnCfgKeys, Acc).
 
 ensure_binary(ClientId) when is_atom(ClientId) ->
-    ensure_binary(atom_to_binary(ClientId, utf8));
+  ensure_binary(atom_to_binary(ClientId, utf8));
 ensure_binary(ClientId) when is_binary(ClientId) ->
-    ClientId.
-
-maybe_start_partitions_sync(#state{
-    client_id = Client, producers_sup = ProducersSup, config = Config
-}) ->
-    case config(sync_partitions, Config, false) of
-        true ->
-            {ok, Pid} = brod_partitions_sync:start_link(Client, ProducersSup, Config),
-            Pid;
-        false ->
-            undefined
-    end.
+  ClientId.
 
 -spec maybe_connect(state(), endpoint()) ->
-    {Result, state()}
-when
-    Result :: {ok, pid()} | {error, any()}.
+        {Result, state()} when Result :: {ok, pid()} | {error, any()}.
 maybe_connect(#state{} = State, Endpoint) ->
-    case find_conn(Endpoint, State#state.payload_conns) of
-        {ok, Pid} -> {{ok, Pid}, State};
-        {error, Reason} -> maybe_connect(State, Endpoint, Reason)
-    end.
+  case find_conn(Endpoint, State#state.payload_conns) of
+    {ok, Pid} -> {{ok, Pid}, State};
+    {error, Reason} -> maybe_connect(State, Endpoint, Reason)
+  end.
 
 -spec maybe_connect(state(), endpoint(), Reason) ->
-    {Result, state()}
-when
-    Reason :: not_found | dead_conn(),
-    Result :: {ok, pid()} | {error, any()}.
+        {Result, state()} when
+          Reason :: not_found | dead_conn(),
+          Result :: {ok, pid()} | {error, any()}.
 maybe_connect(State, Endpoint, not_found) ->
-    %% connect for the first time
-    connect(State, Endpoint);
-maybe_connect(
-    #state{client_id = ClientId} = State,
-    {Host, Port} = Endpoint,
-    ?dead_since(Ts, Reason)
-) ->
-    case is_cooled_down(Ts, State) of
-        true ->
-            connect(State, Endpoint);
-        false ->
-            ?BROD_LOG_ERROR(
-                "~p (re)connect to ~s:~p aborted.\n"
-                "last failure: ~p",
-                [ClientId, Host, Port, Reason]
-            ),
-            {{error, Reason}, State}
-    end.
-
--spec connect(state(), endpoint()) -> {Result, state()} when
-    Result :: {ok, pid()} | {error, any()}.
-connect(
-    #state{
-        client_id = ClientId,
-        payload_conns = Conns
-    } = State,
-    {Host, Port} = Endpoint
-) ->
-    Conn =
-        case do_connect(Endpoint, State) of
-            {ok, Pid} ->
-                ?BROD_LOG_INFO(
-                    "client ~p connected to ~s:~p~n",
-                    [ClientId, Host, Port]
-                ),
-                #conn{
-                    endpoint = Endpoint,
-                    pid = Pid
-                };
-            {error, Reason} ->
-                ?BROD_LOG_ERROR(
-                    "client ~p failed to connect to ~s:~p~n"
-                    "reason:~p",
-                    [ClientId, Host, Port, Reason]
-                ),
-                #conn{
-                    endpoint = Endpoint,
-                    pid = mark_dead(Reason)
-                }
-        end,
-    NewConns = lists:keystore(Endpoint, #conn.endpoint, Conns, Conn),
-    Result =
-        case Conn#conn.pid of
-            P when is_pid(P) -> {ok, P};
-            ?dead_since(_, R) -> {error, R}
-        end,
-    {Result, State#state{payload_conns = NewConns}}.
+  %% connect for the first time
+  connect(State, Endpoint);
+maybe_connect(#state{client_id = ClientId} = State,
+              {Host, Port} = Endpoint, ?dead_since(Ts, Reason)) ->
+  case is_cooled_down(Ts, State) of
+    true ->
+      connect(State, Endpoint);
+    false ->
+      ?BROD_LOG_ERROR("~p (re)connect to ~s:~p aborted.\n"
+                      "last failure: ~p",
+                      [ClientId, Host, Port, Reason]),
+     {{error, Reason}, State}
+  end.
+
+-spec connect(state(), endpoint()) -> {Result, state()}
+        when Result :: {ok, pid()} | {error, any()}.
+connect(#state{ client_id = ClientId
+              , payload_conns = Conns
+              } = State, {Host, Port} = Endpoint) ->
+  Conn =
+    case do_connect(Endpoint, State) of
+      {ok, Pid} ->
+        ?BROD_LOG_INFO("client ~p connected to ~s:~p~n",
+                       [ClientId, Host, Port]),
+        #conn{ endpoint = Endpoint
+             , pid = Pid
+             };
+      {error, Reason} ->
+        ?BROD_LOG_ERROR("client ~p failed to connect to ~s:~p~n"
+                        "reason:~p",
+                        [ClientId, Host, Port, Reason]),
+        #conn{ endpoint = Endpoint
+             , pid = mark_dead(Reason)
+             }
+    end,
+  NewConns = lists:keystore(Endpoint, #conn.endpoint, Conns, Conn),
+  Result = case Conn#conn.pid of
+             P when is_pid(P) -> {ok, P};
+             ?dead_since(_, R) -> {error, R}
+           end,
+  {Result, State#state{payload_conns = NewConns}}.
 
 do_connect(Endpoint, State) ->
-    ConnConfig = conn_config(State),
-    kpro:connect(Endpoint, ConnConfig).
+  ConnConfig = conn_config(State),
+  kpro:connect(Endpoint, ConnConfig).
 
 %% Handle connection pid EXIT event, for payload sockets keep the timestamp,
 %% but do not restart yet. Payload connection will be re-established when a
@@ -873,54 +802,41 @@ do_connect(Endpoint, State) ->
 %% it is cooled down.
 -spec handle_connection_down(state(), pid(), any()) -> state().
 handle_connection_down(#state{meta_conn = Pid} = State, Pid, _Reason) ->
-    State#state{meta_conn = ?undef};
-handle_connection_down(
-    #state{
-        payload_conns = Conns,
-        client_id = ClientId
-    } = State,
-    Pid,
-    Reason
-) ->
-    case lists:keytake(Pid, #conn.pid, Conns) of
-        {value, #conn{endpoint = {Host, Port}} = Conn, Rest} ->
-            ?BROD_LOG_INFO(
-                "client ~p: payload connection down ~s:~p~n"
-                "reason:~p",
-                [ClientId, Host, Port, Reason]
-            ),
-            NewConn = Conn#conn{pid = mark_dead(Reason)},
-            State#state{payload_conns = [NewConn | Rest]};
-        false ->
-            %% stale EXIT message
-            State
-    end.
+  State#state{meta_conn = ?undef};
+handle_connection_down(#state{ payload_conns = Conns
+                             , client_id     = ClientId
+                             } = State, Pid, Reason) ->
+  case lists:keytake(Pid, #conn.pid, Conns) of
+    {value, #conn{endpoint = {Host, Port}} = Conn, Rest} ->
+      ?BROD_LOG_INFO("client ~p: payload connection down ~s:~p~n"
+                     "reason:~p", [ClientId, Host, Port, Reason]),
+      NewConn = Conn#conn{pid = mark_dead(Reason)},
+      State#state{payload_conns = [NewConn | Rest]};
+    false ->
+      %% stale EXIT message
+      State
+  end.
 
 mark_dead(Reason) -> ?dead_since(os:timestamp(), Reason).
 
 -spec find_conn(endpoint(), [conn_state()]) ->
-    %% normal case
-    {ok, pid()}
-    %% first call
-    | {error, not_found}
-    | {error, dead_conn()}.
+        {ok, pid()} %% normal case
+      | {error, not_found} %% first call
+      | {error, dead_conn()}.
 find_conn(Endpoint, Conns) ->
-    case lists:keyfind(Endpoint, #conn.endpoint, Conns) of
-        #conn{pid = Pid} when is_pid(Pid) -> {ok, Pid};
-        #conn{pid = ?dead_since(_, _) = NotAlive} -> {error, NotAlive};
-        false -> {error, not_found}
-    end.
+  case lists:keyfind(Endpoint, #conn.endpoint, Conns) of
+    #conn{pid = Pid} when is_pid(Pid)        -> {ok, Pid};
+    #conn{pid= ?dead_since(_, _) = NotAlive} -> {error, NotAlive};
+    false                                    -> {error, not_found}
+  end.
 
 %% Check if the connection is down for long enough to retry.
 is_cooled_down(Ts, #state{config = Config}) ->
-    Threshold = config(
-        reconnect_cool_down_seconds,
-        Config,
-        ?DEFAULT_RECONNECT_COOL_DOWN_SECONDS
-    ),
-    Now = os:timestamp(),
-    Diff = timer:now_diff(Now, Ts) div 1000000,
-    Diff >= Threshold.
+  Threshold = config(reconnect_cool_down_seconds, Config,
+                     ?DEFAULT_RECONNECT_COOL_DOWN_SECONDS),
+  Now = os:timestamp(),
+  Diff = timer:now_diff(Now, Ts) div 1000000,
+  Diff >= Threshold.
 
 %% call this function after fetched metadata for all topics
 %% to cache the not-found status of a given topics
@@ -936,164 +852,142 @@ maybe_cache_unknown_topic_partition(Ets, [Topic | Rest], TopicMetadata, TopicCac
   maybe_cache_unknown_topic_partition(Ets, Rest, TopicMetadata, TopicCacheTTL).
 
 -spec update_partitions_count_cache(ets:tab(), [kpro:struct()], non_neg_integer()) -> ok.
-update_partitions_count_cache(_Ets, [], _UnknownTopicCacheTtl) ->
-    ok;
+update_partitions_count_cache(_Ets, [], _UnknownTopicCacheTtl) -> ok;
 update_partitions_count_cache(Ets, [TopicMetadata | Rest], UnknownTopicCacheTtl) ->
-    Topic = kf(name, TopicMetadata),
-    case get_partitions_count_in_metadata(TopicMetadata) of
-        {ok, Cnt} ->
-            ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Cnt, {added, now_ts()}});
-        {error, ?unknown_topic_or_partition} = Err ->
-            ets:insert(Ets, {
-                ?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}
-            });
-        {error, _Reason} ->
-            ok
-    end,
-    update_partitions_count_cache(Ets, Rest, UnknownTopicCacheTtl).
+  Topic = kf(name, TopicMetadata),
+  case get_partitions_count_in_metadata(TopicMetadata) of
+    {ok, Cnt} ->
+      ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Cnt, {added, now_ts()}});
+    {error, ?unknown_topic_or_partition} = Err ->
+      ets:insert(Ets, {?TOPIC_METADATA_KEY(Topic), Err, {expire, expire_ts(UnknownTopicCacheTtl)}});
+    {error, _Reason} ->
+      ok
+  end,
+  update_partitions_count_cache(Ets, Rest, UnknownTopicCacheTtl).
 
 %% Get partition counter from cache.
 %% If cache is not hit, send meta data request to retrieve.
--spec do_get_partitions_count(
-    client(),
-    ets:tab(),
-    topic(),
-    #{allow_topic_auto_creation := boolean()}
-) ->
-    {ok, pos_integer()} | {error, any()}.
+-spec do_get_partitions_count(client(), ets:tab(), topic(),
+                              #{allow_topic_auto_creation := boolean()}) ->
+        {ok, pos_integer()} | {error, any()}.
 do_get_partitions_count(Client, Ets, Topic, #{allow_topic_auto_creation := AllowAutoCreation}) ->
-    case lookup_partitions_count_cache(Ets, Topic) of
-        {ok, Result} ->
-            {ok, Result};
-        {error, Reason} ->
-            {error, Reason};
-        false ->
-            %% The topic's partition count is not cached yet,
-            %% try to call get_metadata or get_metadata_safe to populate the cache
-            MetadataResponse =
-                case AllowAutoCreation of
-                    true ->
-                        get_metadata(Client, Topic);
-                    false ->
-                        get_metadata_safe(Client, Topic)
-                end,
-            %% the metadata is returned, no need to look up the cache again
-            %% find the topic's partition count from the metadata directly
-            find_partition_count_in_metadata(MetadataResponse, Topic)
-    end.
+  case lookup_partitions_count_cache(Ets, Topic) of
+    {ok, Result} ->
+      {ok, Result};
+    {error, Reason} ->
+      {error, Reason};
+    false ->
+      %% The topic's partition count is not cached yet,
+      %% try to call get_metadata or get_metadata_safe to populate the cache
+      MetadataResponse =
+        case AllowAutoCreation of
+          true ->
+            get_metadata(Client, Topic);
+          false ->
+            get_metadata_safe(Client, Topic)
+        end,
+      %% the metadata is returned, no need to look up the cache again
+      %% find the topic's partition count from the metadata directly
+      find_partition_count_in_metadata(MetadataResponse, Topic)
+  end.
 
 find_partition_count_in_metadata({ok, Meta}, Topic) ->
-    TopicMetadataArray = kf(topics, Meta),
-    find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic);
+  TopicMetadataArray = kf(topics, Meta),
+  find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic);
 find_partition_count_in_metadata({error, Reason}, _) ->
-    {error, Reason}.
+  {error, Reason}.
 
 find_partition_count_in_topic_metadata_array(TopicMetadataArray, Topic) ->
-    FilterF = fun
-        (#{name := N}) when N =:= Topic -> true;
-        (_) -> false
-    end,
-    case lists:filter(FilterF, TopicMetadataArray) of
-        [TopicMetadata] ->
-            get_partitions_count_in_metadata(TopicMetadata);
-        [] ->
-            {error, unknown_topic_or_partition}
-    end.
+  FilterF = fun(#{name := N}) when N =:= Topic -> true;
+               (_) -> false
+            end,
+  case lists:filter(FilterF, TopicMetadataArray) of
+    [TopicMetadata] ->
+      get_partitions_count_in_metadata(TopicMetadata);
+    [] ->
+      {error, unknown_topic_or_partition}
+  end.
 
 -spec lookup_partitions_count_cache(ets:tab(), ?undef | topic()) ->
-    {ok, pos_integer()} | {error, any()} | false.
-lookup_partitions_count_cache(_Ets, ?undef) ->
-    false;
+        {ok, pos_integer()} | {error, any()} | false.
+lookup_partitions_count_cache(_Ets, ?undef) -> false;
 lookup_partitions_count_cache(Ets, Topic) ->
-    try ets:lookup(Ets, ?TOPIC_METADATA_KEY(Topic)) of
-        [{_, Count, _Ts}] when is_integer(Count) ->
-            {ok, Count};
-        [{_, {error, Reason}, {expire, ExpireTs}}] when is_integer(ExpireTs) ->
-            case is_expired(ExpireTs) of
-                true -> {error, Reason};
-                false -> false
-            end;
-        [] ->
-            false
-    catch
-        error:badarg ->
-            {error, client_down}
-    end.
+  try ets:lookup(Ets, ?TOPIC_METADATA_KEY(Topic)) of
+    [{_, Count, _Ts}] when is_integer(Count) ->
+      {ok, Count};
+    [{_, {error, Reason}, {expire, ExpireTs}}] when is_integer(ExpireTs) ->
+      case is_expired(ExpireTs) of
+        true  -> {error, Reason};
+        false -> false
+      end;
+    [] ->
+      false
+  catch
+    error : badarg ->
+      {error, client_down}
+  end.
 
 -spec get_partitions_count_in_metadata(kpro:struct()) ->
-    {ok, pos_integer()} | {error, any()}.
+        {ok, pos_integer()} | {error, any()}.
 get_partitions_count_in_metadata(TopicMetadata) ->
-    ErrorCode = kf(error_code, TopicMetadata),
-    Partitions = kf(partitions, TopicMetadata),
-    case ?IS_ERROR(ErrorCode) of
-        true -> {error, ErrorCode};
-        false -> {ok, erlang:length(Partitions)}
-    end.
-
--spec maybe_start_producer(
-    client(),
-    topic(),
-    partition(),
-    {error, any()}
-) ->
-    ok | {error, any()}.
+  ErrorCode = kf(error_code, TopicMetadata),
+  Partitions = kf(partitions, TopicMetadata),
+  case ?IS_ERROR(ErrorCode) of
+    true  -> {error, ErrorCode};
+    false -> {ok, erlang:length(Partitions)}
+  end.
+
+-spec maybe_start_producer(client(), topic(),
+                           partition(), {error, any()}) ->
+        ok | {error, any()}.
 maybe_start_producer(Client, Topic, Partition, Error) ->
-    %% try to start a producer for the given topic if
-    %% auto_start_producers option is enabled for the client
-    case safe_gen_call(Client, {auto_start_producer, Topic}, infinity) of
-        ok ->
-            get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition));
-        {error, disabled} ->
-            Error;
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  %% try to start a producer for the given topic if
+  %% auto_start_producers option is enabled for the client
+  case safe_gen_call(Client, {auto_start_producer, Topic}, infinity) of
+    ok ->
+      get_partition_worker(Client, ?PRODUCER_KEY(Topic, Partition));
+    {error, disabled} ->
+      Error;
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 -spec request_sync(state(), kpro:req()) ->
-    {ok, kpro:rsp()} | {error, any()}.
+        {ok, kpro:rsp()} | {error, any()}.
 request_sync(State, Request) ->
-    Pid = get_metadata_connection(State),
-    Timeout = timeout(State),
-    kpro:request_sync(Pid, Request, Timeout).
+  Pid = get_metadata_connection(State),
+  Timeout = timeout(State),
+  kpro:request_sync(Pid, Request, Timeout).
 
 do_start_producer(TopicName, ProducerConfig, State) ->
-    SupPid = State#state.producers_sup,
-    F = fun() ->
-        brod_producers_sup:start_producer(
-            SupPid,
-            self(),
-            TopicName,
-            ProducerConfig
-        )
-    end,
-    ensure_partition_workers(TopicName, State, F).
+  SupPid = State#state.producers_sup,
+  F = fun() ->
+        brod_producers_sup:start_producer(SupPid, self(),
+                                          TopicName, ProducerConfig)
+      end,
+  ensure_partition_workers(TopicName, State, F).
 
 do_start_consumer(TopicName, ConsumerConfig, State) ->
-    SupPid = State#state.consumers_sup,
-    F = fun() ->
-        brod_consumers_sup:start_consumer(
-            SupPid,
-            self(),
-            TopicName,
-            ConsumerConfig
-        )
-    end,
-    ensure_partition_workers(TopicName, State, F).
+  SupPid = State#state.consumers_sup,
+  F = fun() ->
+        brod_consumers_sup:start_consumer(SupPid, self(),
+                                          TopicName, ConsumerConfig)
+      end,
+  ensure_partition_workers(TopicName, State, F).
 
 ensure_partition_workers(TopicName, State, F) ->
-    with_ok(
-        validate_topic_existence(TopicName, State, _IsRetry = false),
-        fun(ok, NewState) ->
-            case F() of
-                {ok, _Pid} ->
-                    {ok, NewState};
-                {error, {already_started, _Pid}} ->
-                    {ok, NewState};
-                {error, Reason} ->
-                    {{error, Reason}, NewState}
-            end
-        end
-    ).
+  with_ok(
+    validate_topic_existence(TopicName, State, _IsRetry = false),
+    fun(ok, NewState) ->
+      case F() of
+        {ok, _Pid} ->
+          {ok, NewState};
+        {error, {already_started, _Pid}} ->
+          {ok, NewState};
+        {error, Reason} ->
+          {{error, Reason}, NewState}
+      end
+    end).
 
 -spec maybe_start_partition_producer(TopicsMetadata, Producers, Topics, ProducerSup) -> ok
 when
@@ -1157,20 +1051,20 @@ filter_topics(TopicsMetadataArray) ->
   maps:from_list(NoErrors).
 
 %% Catches exit exceptions when making gen_server:call.
--spec safe_gen_call(pid() | atom(), Call, Timeout) -> Return when
-    Call :: term(),
-    Timeout :: infinity | integer(),
-    Return :: ok | {ok, term()} | {error, Reason},
-    Reason :: client_down | {client_down, any()} | any().
+-spec safe_gen_call(pid() | atom(), Call, Timeout) -> Return
+        when Call    :: term(),
+             Timeout :: infinity | integer(),
+             Return  :: ok | {ok, term()} | {error, Reason},
+             Reason  :: client_down | {client_down, any()} | any().
 safe_gen_call(Server, Call, Timeout) ->
-    try
-        gen_server:call(Server, Call, Timeout)
-    catch
-        exit:{noproc, _} ->
-            {error, client_down};
-        exit:{Reason, _} ->
-            {error, {client_down, Reason}}
-    end.
+  try
+    gen_server:call(Server, Call, Timeout)
+  catch
+    exit : {noproc, _} ->
+      {error, client_down};
+    exit : {Reason, _} ->
+      {error, {client_down, Reason}}
+  end.
 
 -spec kf(kpro:field_name(), kpro:struct()) -> kpro:field_value().
 kf(FieldName, Struct) -> kpro:find(FieldName, Struct).
@@ -1188,4 +1082,4 @@ now_ts() -> erlang:monotonic_time(millisecond).
 %%% Local Variables:
 %%% allout-layout: t
 %%% erlang-indent-level: 2
-%%% End:
+%%% End:
\ No newline at end of file
diff --git a/src/brod_partitions_sync.erl b/src/brod_partitions_sync.erl
index be76eecc..61a359fd 100644
--- a/src/brod_partitions_sync.erl
+++ b/src/brod_partitions_sync.erl
@@ -163,4 +163,4 @@ get_metadata_for_topics(Client, Topics) ->
         {error, Error} ->
             ?BROD_LOG_ERROR("Partitions Sync Bootstrap Error: ~p", [Error]),
             []
-    end.
+    end.
\ No newline at end of file

From aacb50d4d2571f91740de2dc9262c356d9e3cd9f Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 20:22:45 +0000
Subject: [PATCH 12/15] overlay changes

---
 src/brod_client.erl | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index 95ef2ce1..aaa995f8 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -73,6 +73,7 @@
 -define(DEFAULT_RECONNECT_COOL_DOWN_SECONDS, 1).
 -define(DEFAULT_GET_METADATA_TIMEOUT_SECONDS, 5).
 -define(DEFAULT_UNKNOWN_TOPIC_CACHE_TTL, 120000).
+-define(DEFAULT_SYNC_METADATA_INTERVAL_SECONDS, 60).
 
 %% ClientId as ets table name.
 -define(ETS(ClientId), ClientId).
@@ -131,6 +132,7 @@
         , consumers_sup        :: ?undef | pid()
         , config               :: ?undef | config()
         , workers_tab          :: ?undef | ets:tab()
+        , partitions_sync :: ?undef | pid()
         }).
 
 -type state() :: #state{}.
@@ -363,13 +365,20 @@ handle_continue(init, State0) ->
   State1 = ensure_metadata_connection(State0),
   {ok, ProducersSupPid} = brod_producers_sup:start_link(),
   {ok, ConsumersSupPid} = brod_consumers_sup:start_link(),
-  State = State1#state{ bootstrap_endpoints = Endpoints
+  State2 = State1#state{ bootstrap_endpoints = Endpoints
                       , producers_sup       = ProducersSupPid
                       , consumers_sup       = ConsumersSupPid
                       },
+  State = State2#state{partitions_sync = maybe_start_partitions_sync(State2)},
   {noreply, State}.
 
 %% @private
+handle_info({'EXIT', Pid, Reason}, #state{ client_id        = ClientId
+                                         , partitions_sync  = Pid
+                                        } = State) ->
+    ?BROD_LOG_ERROR("client ~p partitions sync down~nReason: ~p", [ClientId, Pid, Reason]),
+    NewState = State#state{partitions_sync = maybe_start_partitions_sync(State)},
+    {noreply, NewState};
 handle_info({'EXIT', Pid, Reason}, #state{ client_id     = ClientId
                                          , producers_sup = Pid
                                          } = State) ->
@@ -796,6 +805,17 @@ do_connect(Endpoint, State) ->
   ConnConfig = conn_config(State),
   kpro:connect(Endpoint, ConnConfig).
 
+maybe_start_partitions_sync(#state{ client_id = Client
+                                  , producers_sup = ProducersSup 
+                                  , config = Config }) ->
+  case config(sync_partitions, Config, false) of
+    true ->
+      {ok, Pid} = brod_partitions_sync:start_link(Client, ProducersSup, Config),
+      Pid;
+    false ->
+      undefined
+  end.
+
 %% Handle connection pid EXIT event, for payload sockets keep the timestamp,
 %% but do not restart yet. Payload connection will be re-established when a
 %% per-partition worker restarts and requests for a connection after

From 2a7f280bb3debc8b0f97d3f5cc05e86b279c92b3 Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 20:27:07 +0000
Subject: [PATCH 13/15] remove fmt changes in prod sup

---
 src/brod_producers_sup.erl | 163 +++++++++++++++++--------------------
 1 file changed, 75 insertions(+), 88 deletions(-)

diff --git a/src/brod_producers_sup.erl b/src/brod_producers_sup.erl
index c242ff64..ccd17a9a 100644
--- a/src/brod_producers_sup.erl
+++ b/src/brod_producers_sup.erl
@@ -54,14 +54,14 @@
 %% @end
 -spec start_link() -> {ok, pid()}.
 start_link() ->
-    brod_supervisor3:start_link(?MODULE, ?TOPICS_SUP).
+  brod_supervisor3:start_link(?MODULE, ?TOPICS_SUP).
 
 %% @doc Dynamically start a per-topic supervisor
 -spec start_producer(pid(), pid(), brod:topic(), brod:producer_config()) ->
-    {ok, pid()} | {error, any()}.
+                        {ok, pid()} | {error, any()}.
 start_producer(SupPid, ClientPid, TopicName, Config) ->
-    Spec = producers_sup_spec(ClientPid, TopicName, Config),
-    brod_supervisor3:start_child(SupPid, Spec).
+  Spec = producers_sup_spec(ClientPid, TopicName, Config),
+  brod_supervisor3:start_child(SupPid, Spec).
 
 %% @doc Dynamically start a partition producer
 -spec start_producer(pid(), pid(), brod:topic(), brod:partition(), brod:producer_config()) ->
@@ -73,37 +73,34 @@ start_producer(SupPid, ClientPid, Topic, Partition, Config) ->
 %% @doc Dynamically stop a per-topic supervisor
 -spec stop_producer(pid(), brod:topic()) -> ok | {}.
 stop_producer(SupPid, TopicName) ->
-    brod_supervisor3:terminate_child(SupPid, TopicName),
-    brod_supervisor3:delete_child(SupPid, TopicName).
+  brod_supervisor3:terminate_child(SupPid, TopicName),
+  brod_supervisor3:delete_child(SupPid, TopicName).
 
 %% @doc Find a brod_producer process pid running under ?PARTITIONS_SUP.
 -spec find_producer(pid(), brod:topic(), brod:partition()) ->
-    {ok, pid()} | {error, Reason}
-when
-    Reason ::
-        {producer_not_found, brod:topic()}
-        | {producer_not_found, brod:topic(), brod:partition()}
-        | {producer_down, any()}.
+                       {ok, pid()} | {error, Reason} when
+        Reason :: {producer_not_found, brod:topic()}
+                | {producer_not_found, brod:topic(), brod:partition()}
+                | {producer_down, any()}.
 find_producer(SupPid, Topic, Partition) ->
-    case brod_supervisor3:find_child(SupPid, Topic) of
-        [] ->
-            %% no such topic worker started,
-            %% check sys.config or brod:start_link_client args
-            {error, {producer_not_found, Topic}};
-        [PartitionsSupPid] ->
-            try
-                case brod_supervisor3:find_child(PartitionsSupPid, Partition) of
-                    [] ->
-                        %% no such partition?
-                        {error, {producer_not_found, Topic, Partition}};
-                    [Pid] ->
-                        {ok, Pid}
-                end
-            catch
-                exit:{Reason, _} ->
-                    {error, {producer_down, Reason}}
-            end
-    end.
+  case brod_supervisor3:find_child(SupPid, Topic) of
+    [] ->
+      %% no such topic worker started,
+      %% check sys.config or brod:start_link_client args
+      {error, {producer_not_found, Topic}};
+    [PartitionsSupPid] ->
+      try
+        case brod_supervisor3:find_child(PartitionsSupPid, Partition) of
+          [] ->
+            %% no such partition?
+            {error, {producer_not_found, Topic, Partition}};
+          [Pid] ->
+            {ok, Pid}
+        end
+      catch exit : {Reason, _} ->
+        {error, {producer_down, Reason}}
+      end
+  end.
 
 %% @doc Get topic producer config from producer child specification.
 -spec get_producer_config(pid(), brod:topic(), brod:partition()) ->
@@ -157,77 +154,67 @@ which_producers(Sup) ->
 
 %% @doc brod_supervisor3 callback.
 init(?TOPICS_SUP) ->
-    {ok, {{one_for_one, 0, 1}, []}};
+  {ok, {{one_for_one, 0, 1}, []}};
 init({?PARTITIONS_SUP, _ClientPid, _Topic, _Config}) ->
-    post_init.
+  post_init.
 
 post_init({?PARTITIONS_SUP, ClientPid, Topic, Config}) ->
-    case brod_client:get_partitions_count(ClientPid, Topic) of
-        {ok, PartitionsCnt} ->
-            Children = [
-                producer_spec(ClientPid, Topic, Partition, Config)
-             || Partition <- lists:seq(0, PartitionsCnt - 1)
-            ],
-            %% Producer may crash in case of exception in case of network failure,
-            %% or error code received in produce response (e.g. leader transition)
-            %% In any case, restart right away will erry likely fail again.
-            %% Hence set MaxR=0 here to cool-down for a configurable N-seconds
-            %% before supervisor tries to restart it.
-            {ok, {{one_for_one, 0, 1}, Children}};
-        {error, Reason} ->
-            {error, Reason}
-    end.
+  case brod_client:get_partitions_count(ClientPid, Topic) of
+    {ok, PartitionsCnt} ->
+      Children = [ producer_spec(ClientPid, Topic, Partition, Config)
+                 || Partition <- lists:seq(0, PartitionsCnt - 1) ],
+      %% Producer may crash in case of exception in case of network failure,
+      %% or error code received in produce response (e.g. leader transition)
+      %% In any case, restart right away will erry likely fail again.
+      %% Hence set MaxR=0 here to cool-down for a configurable N-seconds
+      %% before supervisor tries to restart it.
+      {ok, {{one_for_one, 0, 1}, Children}};
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
 producers_sup_spec(ClientPid, TopicName, Config0) ->
-    {Config, DelaySecs} =
-        take_delay_secs(
-            Config0,
-            topic_restart_delay_seconds,
-            ?DEFAULT_PARTITIONS_SUP_RESTART_DELAY
-        ),
-    Args = [?MODULE, {?PARTITIONS_SUP, ClientPid, TopicName, Config}],
-    {
-        _Id = TopicName,
-        _Start = {brod_supervisor3, start_link, Args},
-        _Restart = {permanent, DelaySecs},
-        _Shutdown = infinity,
-        _Type = supervisor,
-        _Module = [?MODULE]
-    }.
+  {Config, DelaySecs} =
+    take_delay_secs(Config0, topic_restart_delay_seconds,
+                    ?DEFAULT_PARTITIONS_SUP_RESTART_DELAY),
+  Args = [?MODULE, {?PARTITIONS_SUP, ClientPid, TopicName, Config}],
+  { _Id       = TopicName
+  , _Start    = {brod_supervisor3, start_link, Args}
+  , _Restart  = {permanent, DelaySecs}
+  , _Shutdown = infinity
+  , _Type     = supervisor
+  , _Module   = [?MODULE]
+  }.
 
 producer_spec(ClientPid, Topic, Partition, Config0) ->
-    {Config, DelaySecs} =
-        take_delay_secs(
-            Config0,
-            partition_restart_delay_seconds,
-            ?DEFAULT_PRODUCER_RESTART_DELAY
-        ),
-    Args = [ClientPid, Topic, Partition, Config],
-    {
-        _Id = Partition,
-        _Start = {brod_producer, start_link, Args},
-        _Restart = {permanent, DelaySecs},
-        _Shutdown = 5000,
-        _Type = worker,
-        _Module = [brod_producer]
-    }.
+  {Config, DelaySecs} =
+    take_delay_secs(Config0, partition_restart_delay_seconds,
+                    ?DEFAULT_PRODUCER_RESTART_DELAY),
+  Args      = [ClientPid, Topic, Partition, Config],
+  { _Id       = Partition
+  , _Start    = {brod_producer, start_link, Args}
+  , _Restart  = {permanent, DelaySecs}
+  , _Shutdown = 5000
+  , _Type     = worker
+  , _Module   = [brod_producer]
+  }.
 
 %%%_* Internal Functions =======================================================
 
 -spec take_delay_secs(brod:producer_config(), atom(), integer()) ->
-    {brod:producer_config(), integer()}.
+        {brod:producer_config(), integer()}.
 take_delay_secs(Config, Name, DefaultValue) ->
-    Secs =
-        case proplists:get_value(Name, Config) of
-            N when is_integer(N) andalso N >= ?MIN_SUPERVISOR3_DELAY_SECS ->
-                N;
-            _ ->
-                DefaultValue
-        end,
-    {proplists:delete(Name, Config), Secs}.
+  Secs =
+    case proplists:get_value(Name, Config) of
+      N when is_integer(N) andalso N >= ?MIN_SUPERVISOR3_DELAY_SECS ->
+        N;
+      _ ->
+        DefaultValue
+    end,
+  {proplists:delete(Name, Config), Secs}.
 
 %%%_* Emacs ====================================================================
 %%% Local Variables:
 %%% allout-layout: t
 %%% erlang-indent-level: 2
-%%% End:
+%%% End:
\ No newline at end of file

From 6b68b3028dc5c4b3fd3cefc77ea032f7bf2f4f2b Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 20:45:26 +0000
Subject: [PATCH 14/15] lint

---
 src/brod_client.erl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/brod_client.erl b/src/brod_client.erl
index aaa995f8..06d5bc9e 100644
--- a/src/brod_client.erl
+++ b/src/brod_client.erl
@@ -806,7 +806,7 @@ do_connect(Endpoint, State) ->
   kpro:connect(Endpoint, ConnConfig).
 
 maybe_start_partitions_sync(#state{ client_id = Client
-                                  , producers_sup = ProducersSup 
+                                  , producers_sup = ProducersSup
                                   , config = Config }) ->
   case config(sync_partitions, Config, false) of
     true ->

From 9c868997a1ca5e6a3bda4bd2d4443c0ebf92b14a Mon Sep 17 00:00:00 2001
From: Chris Kempton <chris.kempton@leotechnologies.com>
Date: Wed, 5 Nov 2025 20:55:01 +0000
Subject: [PATCH 15/15] tests passing

---
 test/brod_SUITE.erl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/brod_SUITE.erl b/test/brod_SUITE.erl
index 1f32727c..ea34c668 100644
--- a/test/brod_SUITE.erl
+++ b/test/brod_SUITE.erl
@@ -76,7 +76,7 @@ t_create_update_delete_topics(Config) when is_list(Config) ->
       topic => Topic,
       new_partitions => #{
         count => 2,
-        assignment => [[0]]
+        assignment => [[1]]
       }
     }
   ],