MIME-Version: 1.0
References: <CAKK5BkESSc69sp2TiTWHvvOHCUey0rDWXSrR9pinyRqyfamUYg@mail.gmail.com>
 <F1096CFA-CF22-4B47-A10B-D1F837BF7AF1@yandex-team.ru> <CAKK5BkHt0rELF_Rn-=qJMLg=77NNqiUJ1hV3uVG-BqfHJ=tFfQ@mail.gmail.com>
 <CAKK5BkFxUk3yuRDrM1qWUerhwq3ig6L41CGrHWF8rD7c7xH8_Q@mail.gmail.com>
In-Reply-To: <CAKK5BkFxUk3yuRDrM1qWUerhwq3ig6L41CGrHWF8rD7c7xH8_Q@mail.gmail.com>
From: Andrew Jackson <andrewjackson947@gmail.com>
Date: Mon, 24 Feb 2025 12:06:59 -0600
Message-ID: <CAKK5BkF=0-z2k_8-m=cqspioEkgFPOXNkdjLwLOUR=N+k5H1JQ@mail.gmail.com>
Subject: Re: Add Option To Check All Addresses For Matching target_session_attr
To: Andrey Borodin <x4mmm@yandex-team.ru>
Cc: Vladimir Sitnikov <sitnikov.vladimir@gmail.com>, Dave Page <dpage@pgadmin.org>, 
	pgsql-hackers <pgsql-hackers@postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000fca401062ee73681"
Archived-At: <https://www.postgresql.org/message-id/CAKK5BkF%3D0-z2k_8-m%3DcqspioEkgFPOXNkdjLwLOUR%3DN%2Bk5H1JQ%40mail.gmail.com>
Precedence: bulk

--000000000000fca401062ee73681
Content-Type: multipart/alternative; boundary="000000000000fca3ff062ee7367f"

--000000000000fca3ff062ee7367f
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

The previous patch had a mistake in a reference in the documentation. This
should fix it.

On Mon, Feb 24, 2025 at 10:07=E2=80=AFAM Andrew Jackson <andrewjackson947@g=
mail.com>
wrote:

> Looks like this needed another rebase to account for the oauth commit.
> Rebase attached.
>
> On Mon, Feb 24, 2025 at 9:38=E2=80=AFAM Andrew Jackson <andrewjackson947@=
gmail.com>
> wrote:
>
>> Hi,
>>
>> Thank you for the review!
>>
>> Review Response
>>
>> - Made a first pass at a real commit message
>> - Fixed the condition on the if statement to use strcmp
>> - Added a test suite in the files `src/interfaces/libpq/t/
>> 006_target_session_attr_dns.pl` and `src/interfaces/libpq/t/
>> 007_load_balance_dns_check_all_addrs.pl` which checks the
>> target_session_attrs as when used with and without load balancing.
>>
>> Regarding the name of the variable itself I am definitely open to
>> opinions on this. I didn't put too much thought initially and just chose
>> `check_all_addrs`. I feel like given that it modifies the behaviour of
>> `target_session_attrs` ideally it should reference that in the name but
>> that would make that variable name very long: something akin to
>> `target_session_attrs_check_all_addrs`.
>>
>> Context
>>
>> I tested some drivers as well and found that pgx, psycopg, and
>> rust-postgres all traverse every IP address when looking for a matching
>> target_session_attrs. Asyncpg and psycopg2 on the other hand follow libp=
q
>> and terminate additional attempts after the first failure. Given this it
>> seems like there is a decent amount of fragmentation in the ecosystem as=
 to
>> how exactly to implement this feature. I believe some drivers choose to
>> traverse all addresses because they have users target the same use case
>> outlined above.
>>
>> Thanks again,
>> Andrew Jackson
>>
>> On Sun, Feb 16, 2025 at 6:03=E2=80=AFAM Andrey Borodin <x4mmm@yandex-tea=
m.ru>
>> wrote:
>>
>>> Hi Andrew!
>>>
>>> cc Jelte, I suspect he might be interested.
>>>
>>> > On 20 Nov 2024, at 20:51, Andrew Jackson <andrewjackson947@gmail.com>
>>> wrote:
>>> >
>>> > Would appreciate any feedback on the applicability/relevancy of the
>>> goal here or the implementation.
>>>
>>> Thank you for raising the issue. Following our discussion in Discord I'=
m
>>> putting my thoughts to list.
>>>
>>>
>>> Context
>>>
>>> A DNS record might return several IPs. Consider we have a connection
>>> string with "host=3DA,B", A is resolved to 1.1.1.1,2.2.2.2, B to
>>> 3.3.3.3,4.4.4.4.
>>> If we connect with "target_session_attrs=3Dread-write" IPs 1.1.1.1 and
>>> 3.3.3.3 will be probed, but 2.2.2.2 and 4.4.4.4 won't (if 1.1.1.1 and
>>> 3.3.3.3 responded).
>>>
>>> If we enable libpq load balancing some random 2 IPs will be probed.
>>>
>>> IMO it's a bug, at least when load balancing is enabled. Let's consider
>>> if we can change default behavior here. I suspect we can't do it for
>>> "load_balance_hosts=3Ddisable". And even for load balancing this might =
be too
>>> unexpected change for someone.
>>>
>>> Further I only consider proposal not as a bug fix, but as a feature.
>>>
>>> In Discord we have surveyed some other drivers.
>>> pgx treats all IPs as different servers [1]. npgsql goes through all IP=
s
>>> one-by-one always [2]. PGJDBC are somewhat in a decision process [3] (c=
c
>>> Dave and Vladimir, if they would like to provide some input).
>>>
>>>
>>> Review
>>>
>>> The patch needs a rebase. It's trivial, so please fine attached. The
>>> patch needs real commit message, it's not trivial :)
>>>
>>> We definitely need to adjust tests [0]. We need to change
>>> 004_load_balance_dns.pl so that it tests target_session_attrs too.
>>>
>>> Some documentation would be nice.
>>>
>>> I do not like how this check is performed
>>> +                                               if
>>> (conn->check_all_addrs && conn->check_all_addrs[0] =3D=3D '1')
>>> Let's make it like load balancing is done [4].
>>>
>>> Finally, let's think about naming alternatives for "check_all_addrs".
>>>
>>> I think that's enough for a first round of the review. If it's not a
>>> bug, but a feature - it's a very narrow window to get to 18. But we mig=
ht
>>> be lucky...
>>>
>>> Thank you!
>>>
>>>
>>> Best regards, Andrey Borodin.
>>>
>>> [0]
>>> https://github.com/postgres/postgres/commit/7f5b19817eaf38e70ad1153db4e=
644ee9456853e#diff-b05b74d2a97d7f74d4311ba1702d732f0df1b101c6ac99c146b51215=
174cf3ffR94
>>> [1] https://github.com/jackc/pgx/blob/master/pgconn/pgconn.go#L177
>>> [2]
>>> https://github.com/npgsql/npgsql/blob/7f1a59fa8dc1ccc34a70154f49a768e1a=
bf826ba/src/Npgsql/Internal/NpgsqlConnector.cs#L986
>>> [3] https://github.com/pgjdbc/pgjdbc/pull/3012#discussion_r1408069450
>>> [4]
>>> https://github.com/postgres/postgres/commit/7f5b19817eaf38e70ad1153db4e=
644ee9456853e#diff-8d819454e061b9d4cdae9c8922ded05753a629d70f2ac1de1d4f6d5a=
4aeb7f68R1660
>>>
>>

--000000000000fca3ff062ee7367f
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">The previous patch had a mistake in a reference in the doc=
umentation. This should fix it.</div><br><div class=3D"gmail_quote gmail_qu=
ote_container"><div dir=3D"ltr" class=3D"gmail_attr">On Mon, Feb 24, 2025 a=
t 10:07=E2=80=AFAM Andrew Jackson &lt;<a href=3D"mailto:andrewjackson947@gm=
ail.com">andrewjackson947@gmail.com</a>&gt; wrote:<br></div><blockquote cla=
ss=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid =
rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr">Looks like this needed =
another rebase to account=C2=A0for the oauth commit. Rebase attached.</div>=
<br><div class=3D"gmail_quote"><div dir=3D"ltr" class=3D"gmail_attr">On Mon=
, Feb 24, 2025 at 9:38=E2=80=AFAM Andrew Jackson &lt;<a href=3D"mailto:andr=
ewjackson947@gmail.com" target=3D"_blank">andrewjackson947@gmail.com</a>&gt=
; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px=
 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div di=
r=3D"ltr">Hi,<div><div><br>Thank you for the review!</div><div><br></div></=
div><div>Review Response</div><div><br></div><div>- Made a first pass at a =
real commit message</div><div>- Fixed the condition on the if statement to =
use strcmp</div><div>- Added a test suite in the files `src/interfaces/libp=
q/t/<a href=3D"http://006_target_session_attr_dns.pl" target=3D"_blank">006=
_target_session_attr_dns.pl</a>` and `src/interfaces/libpq/t/<a href=3D"htt=
p://007_load_balance_dns_check_all_addrs.pl" target=3D"_blank">007_load_bal=
ance_dns_check_all_addrs.pl</a>` which checks the target_session_attrs as w=
hen used with and without load balancing.</div><div><br></div><div>Regardin=
g the name of the variable itself I am=C2=A0definitely open to opinions on =
this. I didn&#39;t put too much thought initially and just chose `check_all=
_addrs`. I feel like given that it modifies the behaviour of `target_sessio=
n_attrs` ideally it should reference that in the name but that would make t=
hat variable name very long: something akin to `target_session_attrs_check_=
all_addrs`.=C2=A0</div><div><br></div><div>Context</div><div><br></div><div=
>I tested some drivers as well and found that pgx, psycopg, and rust-postgr=
es all traverse every IP address when looking for a matching target_session=
_attrs. Asyncpg and psycopg2 on the other hand follow libpq and terminate a=
dditional attempts after the first failure. Given this it seems like there =
is a decent amount of fragmentation in the ecosystem as to how exactly to i=
mplement this feature. I believe some drivers choose to traverse all addres=
ses because they have users target the same use case outlined above.=C2=A0<=
/div><div><br></div><div>Thanks again,</div><div>Andrew Jackson</div></div>=
<br><div class=3D"gmail_quote"><div dir=3D"ltr" class=3D"gmail_attr">On Sun=
, Feb 16, 2025 at 6:03=E2=80=AFAM Andrey Borodin &lt;<a href=3D"mailto:x4mm=
m@yandex-team.ru" target=3D"_blank">x4mmm@yandex-team.ru</a>&gt; wrote:<br>=
</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;b=
order-left:1px solid rgb(204,204,204);padding-left:1ex">Hi Andrew!<br>
<br>
cc Jelte, I suspect he might be interested.<br>
<br>
&gt; On 20 Nov 2024, at 20:51, Andrew Jackson &lt;<a href=3D"mailto:andrewj=
ackson947@gmail.com" target=3D"_blank">andrewjackson947@gmail.com</a>&gt; w=
rote:<br>
&gt; <br>
&gt; Would appreciate any feedback on the applicability/relevancy of the go=
al here or the implementation.<br>
<br>
Thank you for raising the issue. Following our discussion in Discord I&#39;=
m putting my thoughts to list.<br>
<br>
<br>
Context<br>
<br>
A DNS record might return several IPs. Consider we have a connection string=
 with &quot;host=3DA,B&quot;, A is resolved to 1.1.1.1,2.2.2.2, B to 3.3.3.=
3,4.4.4.4.<br>
If we connect with &quot;target_session_attrs=3Dread-write&quot; IPs 1.1.1.=
1 and 3.3.3.3 will be probed, but 2.2.2.2 and 4.4.4.4 won&#39;t (if 1.1.1.1=
 and 3.3.3.3 responded).<br>
<br>
If we enable libpq load balancing some random 2 IPs will be probed.<br>
<br>
IMO it&#39;s a bug, at least when load balancing is enabled. Let&#39;s cons=
ider if we can change default behavior here. I suspect we can&#39;t do it f=
or &quot;load_balance_hosts=3Ddisable&quot;. And even for load balancing th=
is might be too unexpected change for someone.<br>
<br>
Further I only consider proposal not as a bug fix, but as a feature.<br>
<br>
In Discord we have surveyed some other drivers.<br>
pgx treats all IPs as different servers [1]. npgsql goes through all IPs on=
e-by-one always [2]. PGJDBC are somewhat in a decision process [3] (cc Dave=
 and Vladimir, if they would like to provide some input).<br>
<br>
<br>
Review<br>
<br>
The patch needs a rebase. It&#39;s trivial, so please fine attached. The pa=
tch needs real commit message, it&#39;s not trivial :)<br>
<br>
We definitely need to adjust tests [0]. We need to change <a href=3D"http:/=
/004_load_balance_dns.pl" rel=3D"noreferrer" target=3D"_blank">004_load_bal=
ance_dns.pl</a> so that it tests target_session_attrs too.<br>
<br>
Some documentation would be nice.<br>
<br>
I do not like how this check is performed<br>
+=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0if (conn-&gt;check_all_addrs &amp;&amp; conn-&gt;check_=
all_addrs[0] =3D=3D &#39;1&#39;)<br>
Let&#39;s make it like load balancing is done [4].<br>
<br>
Finally, let&#39;s think about naming alternatives for &quot;check_all_addr=
s&quot;.<br>
<br>
I think that&#39;s enough for a first round of the review. If it&#39;s not =
a bug, but a feature - it&#39;s a very narrow window to get to 18. But we m=
ight be lucky...<br>
<br>
Thank you!<br>
<br>
<br>
Best regards, Andrey Borodin.<br>
<br>
[0] <a href=3D"https://github.com/postgres/postgres/commit/7f5b19817eaf38e7=
0ad1153db4e644ee9456853e#diff-b05b74d2a97d7f74d4311ba1702d732f0df1b101c6ac9=
9c146b51215174cf3ffR94" rel=3D"noreferrer" target=3D"_blank">https://github=
.com/postgres/postgres/commit/7f5b19817eaf38e70ad1153db4e644ee9456853e#diff=
-b05b74d2a97d7f74d4311ba1702d732f0df1b101c6ac99c146b51215174cf3ffR94</a><br=
>
[1] <a href=3D"https://github.com/jackc/pgx/blob/master/pgconn/pgconn.go#L1=
77" rel=3D"noreferrer" target=3D"_blank">https://github.com/jackc/pgx/blob/=
master/pgconn/pgconn.go#L177</a><br>
[2] <a href=3D"https://github.com/npgsql/npgsql/blob/7f1a59fa8dc1ccc34a7015=
4f49a768e1abf826ba/src/Npgsql/Internal/NpgsqlConnector.cs#L986" rel=3D"nore=
ferrer" target=3D"_blank">https://github.com/npgsql/npgsql/blob/7f1a59fa8dc=
1ccc34a70154f49a768e1abf826ba/src/Npgsql/Internal/NpgsqlConnector.cs#L986</=
a><br>
[3] <a href=3D"https://github.com/pgjdbc/pgjdbc/pull/3012#discussion_r14080=
69450" rel=3D"noreferrer" target=3D"_blank">https://github.com/pgjdbc/pgjdb=
c/pull/3012#discussion_r1408069450</a><br>
[4] <a href=3D"https://github.com/postgres/postgres/commit/7f5b19817eaf38e7=
0ad1153db4e644ee9456853e#diff-8d819454e061b9d4cdae9c8922ded05753a629d70f2ac=
1de1d4f6d5a4aeb7f68R1660" rel=3D"noreferrer" target=3D"_blank">https://gith=
ub.com/postgres/postgres/commit/7f5b19817eaf38e70ad1153db4e644ee9456853e#di=
ff-8d819454e061b9d4cdae9c8922ded05753a629d70f2ac1de1d4f6d5a4aeb7f68R1660</a=
><br>
</blockquote></div>
</blockquote></div>
</blockquote></div>

--000000000000fca3ff062ee7367f--
--000000000000fca401062ee73681
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v5-0001-Add-option-to-check-all-addrs-for-target_session.patch"
Content-Disposition: attachment; 
	filename="v5-0001-Add-option-to-check-all-addrs-for-target_session.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_m7jddn690>
X-Attachment-Id: f_m7jddn690
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--000000000000fca401062ee73681--