foreach my $ns ( grep {defined} @_ ) {
  if ( _ipv4($ns) || _ipv6($ns) ) {
    push @ip, $ns;
  } else {
    my $defres = ref($self)->new( debug => $self->{debug} );
    $defres->{persistent} = $self->{persistent};
    my $names  = {};
    my $packet = $defres->send( $ns, 'A' );
[download]

That would happen if the nameserver list passed to  ->nameservers(@list) contained a string that wasn't an IP address. It seems really odd to me that name servers would ever be specified as names that needed resolved before they could be used to resolve names... maybe you should debug that first to see what the input is?

Try this: (example of monkey-patching)

  use Net::DNS::Resolver::Base;
  my $orig= \&Net::DNS::Resolver::Base::nameservers;
  local *Net::DNS::Resolver::Base::nameservers= sub {
    my ($self, @servers)= @_;
    print "Current nameservers value: "
      .join(", ", @{$self->{nameservers}//[]})
      ."\n";
    print "Assigning nameservers: ".join(", ", @servers)."\n"
      if @servers > 1;
    $orig->(@_);
  };

  # and then the rest of your program
[download]

I don't have a windows system to test on at the moment (well, not one where I can disable the network adapters and still use it) but that will at least show you what is getting assigned there. On my system, it reveals that the default resovlers are "127.0.0.1" and "::1" before the first call to ->nameservers, so yes that would hang if there was not a nameserver listening on localhost and something tried to assign "foo.example.com" as a nameserver.

Meanwhile, I realized that you can override the default timeouts like this:

  use Net::DNS::Resolver;
  Net::DNS::Resolver->tcp_timeout(1);
  Net::DNS::Resolver->udp_timeout(1);

  # remainder of your program
[download]

sub AUTOLOAD {                          ## Default method
  my ($self) = @_;

  my $name = $AUTOLOAD;
  $name =~ s/.*://;
  croak qq[unknown method "$name"] unless $public_attr{$name};

  no strict 'refs';          ## no critic ProhibitNoStrict
  *{$AUTOLOAD} = sub {
    my $self = shift;
    $self = $self->_defaults unless ref($self);
    $self->{$name} = shift || 0 if scalar @_;
    return $self->{$name};
  };

  goto &{$AUTOLOAD};
}
[download]

It seems really odd to me that name servers would ever be specified as names that needed resolved before they could be used to resolve names...

This is used in the testing/using of authoritative and/or delegated nameservers which are usually specified by name rather than by address (so that they may be rotated, migrated, etc. by the hoster without affecting the delegation). So long as you have bootstrapped correctly by having an initial resolver to do the lookups of the nameserver names it is a handy feature.

---

🦛

Yes for me I get attempts to 127.0.0.1 and ::1 as well

Setting tcp_timeout and udp_timeout changed nothing for me. Having a look in _udp_send the timeout used for can_read is made from the 'retrans' and 'retry' settings. Based on the default values (5 and 4) with the DNS timeout of 2.5s doubling, this results in a timeouts of: 2.5,2.5,5,5,10,10,20,20 for both servers (total 150 seconds).

This reduced the issue to 2.5 seconds:

  Net::DNS::Resolver->tcp_timeout(1);
  Net::DNS::Resolver->udp_timeout(1);
[download]

But then I noticed that the local host name servers are in the defaults as well! So this 'fixes' it by setting the default nameservers to nothing:

  Net::DNS::Resolver->nameserver4([]);
  Net::DNS::Resolver->nameserver6([]);
[download]

Well it sounds like you have enough info now that your problem is solved? If so, wonderful :-)

...but your post still leaves *me* with all kinds of questions, like why you need AnyEvent DNS to work if you don't have any network adapters in the first place, or how you're going to use a name server by host name if you don't have an initial default nameserver to resolve that with :-) I'll point back to my first post here about how if you know what name servers you want to use (like Cloudflare 1.1.1.1 or google 8.8.4.4) you can just pass those directly to AnyEvent::DNS and skip messing with Net::DNS::Resolver. Then if your network is connected, you can reach 1.1.1.1, and if it isn't, it should time out within AnyEvent rather than Net::DNS::Resolver.