{"record":{"id":"898fa0dce2e1165a","repo":"grpc/grpc-java","slug":"address-types-of-nameresolver-s-for-s-not-su","errorCode":null,"errorMessage":"Address types of NameResolver '%s' for '%s' not supported by transport","messagePattern":"Address types of NameResolver '(.+?)' for '(.+?)' not supported by transport","errorType":"validation","errorClass":"IllegalArgumentException","httpStatus":null,"severity":"error","filePath":"core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java","lineNumber":891,"sourceCode":"  }\n\n  @VisibleForTesting\n  static class ResolvedNameResolver {\n    public final UriWrapper targetUri;\n    public final NameResolverProvider provider;\n\n    public ResolvedNameResolver(UriWrapper targetUri, NameResolverProvider provider) {\n      this.targetUri = checkNotNull(targetUri, \"targetUri\");\n      this.provider = checkNotNull(provider, \"provider\");\n    }\n\n    void checkAddressTypes(\n        Collection<Class<? extends SocketAddress>> channelTransportSocketAddressTypes) {\n      if (channelTransportSocketAddressTypes != null) {\n        Collection<Class<? extends SocketAddress>> nameResolverSocketAddressTypes =\n            provider.getProducedSocketAddressTypes();\n        if (!channelTransportSocketAddressTypes.containsAll(nameResolverSocketAddressTypes)) {\n          throw new IllegalArgumentException(\n              String.format(\n                  \"Address types of NameResolver '%s' for '%s' not supported by transport\",\n                  provider.getDefaultScheme(), targetUri));\n        }\n      }\n    }\n  }\n\n  @VisibleForTesting\n  static ResolvedNameResolver getNameResolverProvider(\n      String target, NameResolverRegistry nameResolverRegistry,\n      NameResolverProvider nameResolverProvider) {\n    // Finding a NameResolver. Try using the target string as the URI. If that fails, try prepending\n    // \"dns:///\".\n    NameResolverProvider provider = null;\n    URI targetUri = null;\n    StringBuilder uriSyntaxErrors = new StringBuilder();\n    try {","sourceCodeStart":873,"sourceCodeEnd":909,"githubUrl":"https://github.com/grpc/grpc-java/blob/64daddc1f3d1975670f769f3e97bde8b2ba32d25/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java#L873-L909","documentation":"gRPC validates at channel-build time that every SocketAddress type the NameResolver produces can be understood by the channel's transport. If the name resolver emits address types (e.g. ExternalAddress / custom subclasses) the transport has not registered support for, the builder fails fast with this IllegalArgumentException rather than failing later at connect time.","triggerScenarios":"Building a channel via ManagedChannelImplBuilder/forAddress with a custom NameResolverProvider whose getProducedSocketAddressTypes() returns address classes not contained in the transport's supported SocketAddress types, when nameResolverRegistry verification (checkAddressTypes) is enabled.","commonSituations":"Registering a custom name resolver that produces ExternalAddress objects against a transport (e.g. a plain netty/inprocess channel) that only supports InetSocketAddress; using a custom provider with a mismatched getDefaultScheme and transport.","solutions":["Register the transport's supported address types so it covers all classes the resolver produces, or make the resolver produce supported address types (e.g. InetSocketAddress)","Return the correct set from NameResolverProvider.getProducedSocketAddressTypes() matching what the resolver actually emits","Use a transport that supports the resolver's address types (e.g. an ExternalAddress-aware transport for ExternalAddress)","Bypass the check only deliberately by not registering the resolver against the channel that performs verification"],"exampleFix":"// before\npublic Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {\n  return Collections.singleton(ExternalAddress.class);\n}\n// after\npublic Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {\n  return Collections.singleton(InetSocketAddress.class);\n}","handlingStrategy":"validation","validationCode":"Collection<Class<? extends SocketAddress>> resolverTypes = provider.getProducedSocketAddressTypes();\nif (!transport.getSupportedSocketAddressTypes().containsAll(resolverTypes)) {\n  throw new IllegalArgumentException(\"resolver address types unsupported by transport\");\n}","typeGuard":null,"tryCatchPattern":"try { ManagedChannelBuilder.forTarget(t).build(); } catch (IllegalArgumentException e) { if (e.getMessage().contains(\"not supported by transport\")) { /* swap resolver or transport */ } else throw e; }","preventionTips":["Keep getProducedSocketAddressTypes() in sync with the transport's supported types","Test channel construction for every registered custom name resolver","Prefer standard InetSocketAddress-producing resolvers unless the transport explicitly supports external addresses"],"tags":["grpc","name-resolver","transport","illegal-argument"],"backgroundTag":"invalid-argument-value","analyzedSha":"64daddc1f3d1975670f769f3e97bde8b2ba32d25","analyzedAt":"2026-09-08T06:14:57.704Z","contentChangedAt":"2026-09-08T06:14:57.704Z","schemaVersion":2},"datasetVersion":"2026-09-14T05:17:10.506Z"}