Enable to set provider-specific log level

internal/command/meta_providers.go

@@ -380,7 +380,7 @@ func providerFactory(meta *providercache.CachedProvider) providers.Factory {
 
 		config := &plugin.ClientConfig{
 			HandshakeConfig:  tfplugin.Handshake,
-			Logger:           logging.NewProviderLogger(""),
+			Logger:           logging.NewProviderLogger("", meta.Provider.Type),
 			AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},
 			Managed:          true,
 			Cmd:              exec.Command(execFile),
@@ -446,7 +446,7 @@ func unmanagedProviderFactory(provider addrs.Provider, reattach *plugin.Reattach
 	return func() (providers.Interface, error) {
 		config := &plugin.ClientConfig{
 			HandshakeConfig:  tfplugin.Handshake,
-			Logger:           logging.NewProviderLogger("unmanaged."),
+			Logger:           logging.NewProviderLogger("unmanaged.", provider.Type),
 			AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},
 			Managed:          false,
 			Reattach:         reattach,

internal/logging/logging.go

@@ -125,13 +125,13 @@ func NewLogger(name string) hclog.Logger {
 
 // NewProviderLogger returns a logger for the provider plugin, possibly with a
 // different log level from the global logger.
-func NewProviderLogger(prefix string) hclog.Logger {
+func NewProviderLogger(prefix string, providerTypeName string) hclog.Logger {
 	l := &logPanicWrapper{
 		Logger: logger.Named(prefix + "provider"),
 	}
 
-	level := providerLogLevel()
-	logger.Debug("created provider logger", "level", level)
+	level := providerLogLevel(providerTypeName)
+	logger.Debug("created provider logger", "provider_type", providerTypeName, "level", level)
 
 	l.SetLevel(level)
 	return l
@@ -171,8 +171,25 @@ func CurrentLogLevel() string {
 	return strings.ToUpper(ll.String())
 }
 
-func providerLogLevel() hclog.Level {
-	providerEnvLevel := strings.ToUpper(os.Getenv(envLogProvider))
+func providerLogLevel(providerTypeName string) hclog.Level {
+	var providerEnvLevel string
+
+	// First, try provider-specific environment variable if provider type name is given
+	// e.g., for provider type "aws", check TF_LOG_PROVIDER_AWS
+	if providerTypeName != "" {
+		// Convert provider type name to uppercase and replace hyphens with underscores
+		normalizedName := strings.ToUpper(providerTypeName)
+		normalizedName = strings.ReplaceAll(normalizedName, "-", "_")
+		providerSpecificEnv := fmt.Sprintf("%s_%s", envLogProvider, normalizedName)
+		providerEnvLevel = strings.ToUpper(os.Getenv(providerSpecificEnv))
+	}
+
+	// Fall back to general TF_LOG_PROVIDER
+	if providerEnvLevel == "" {
+		providerEnvLevel = strings.ToUpper(os.Getenv(envLogProvider))
+	}
+
+	// Fall back to general TF_LOG
 	if providerEnvLevel == "" {
 		providerEnvLevel = strings.ToUpper(os.Getenv(envLog))
 	}

internal/rpcapi/dependencies.go

@@ -690,7 +690,7 @@ func providerFactoriesForLocks(locks *depsfile.Locks, pluginsDir *providercache.
 		ret[addr] = func() (providers.Interface, error) {
 			config := &plugin.ClientConfig{
 				HandshakeConfig:  tfplugin.Handshake,
-				Logger:           logging.NewProviderLogger(""),
+				Logger:           logging.NewProviderLogger("", addr.Type),
 				AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},
 				Managed:          true,
 				Cmd:              exec.Command(exeFilename),

internal/rpcapi/dependencies_provider_schema.go

@@ -73,7 +73,7 @@ func unconfiguredProviderPluginInstance(cached *providercache.CachedProvider) (p
 
 	config := &plugin.ClientConfig{
 		HandshakeConfig:  tfplugin.Handshake,
-		Logger:           logging.NewProviderLogger(""),
+		Logger:           logging.NewProviderLogger("", cached.Provider.Type),
 		AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},
 		Managed:          true,
 		Cmd:              exec.Command(execFile),