Enable timeout configuration (#21)

Author: Fodoj

docs/index.md

@@ -45,3 +45,4 @@ provider "openai" {
 - `api_key` (String, Sensitive) Project API key (sk-proj...) for authentication. Note: Use project keys, not admin keys.
 - `api_url` (String) The URL for OpenAI API. If not set, the OPENAI_API_URL environment variable will be used, or the default value of 'https://api.openai.com/v1'.
 - `organization` (String) The Organization ID for OpenAI API operations. If not set, the OPENAI_ORGANIZATION environment variable will be used.
+- `timeout` (Number) Timeout in seconds for API operations. If not set, the OPENAI_TIMEOUT environment variable will be used, or the default value of 300 seconds (5 minutes).

internal/client/client.go

@@ -22,6 +22,7 @@ type OpenAIClient struct {
 	OrganizationID string
 	APIURL         string
 	HTTPClient     *http.Client
+	Timeout        time.Duration // Timeout for all requests
 }
 
 // NewClient creates a new instance of the OpenAI client
@@ -57,17 +58,87 @@ func NewClient(apiKey, organizationID, apiURL string) *OpenAIClient {
 		MaxIdleConnsPerHost:   10,
 	}
 
-	return &OpenAIClient{
+	defaultTimeout := 60 * time.Second
+
+	client := &OpenAIClient{
 		APIKey:         apiKey,
 		OrganizationID: organizationID,
 		APIURL:         apiURL,
 		HTTPClient: &http.Client{
 			Transport: transport,
-			Timeout:   60 * time.Second, // Increased timeout for API operations
+			Timeout:   defaultTimeout,
+		},
+		Timeout: defaultTimeout,
+	}
+
+	return client
+}
+
+// ClientConfig contains configuration options for the OpenAI client
+type ClientConfig struct {
+	APIKey         string
+	OrganizationID string
+	APIURL         string
+	Timeout        time.Duration // Timeout for all operations
+}
+
+// NewClientWithConfig creates a new instance of the OpenAI client with custom configuration
+func NewClientWithConfig(config ClientConfig) *OpenAIClient {
+	// Set default API URL if not provided
+	if config.APIURL == "" {
+		config.APIURL = "https://api.openai.com"
+	}
+
+	// Ensure the URL doesn't end with a slash
+	config.APIURL = strings.TrimSuffix(config.APIURL, "/")
+
+	// Set default timeout if not provided
+	if config.Timeout == 0 {
+		config.Timeout = 60 * time.Second
+	}
+
+	// Debug: Print the client configuration
+	fmt.Printf("DEBUG: Creating new OpenAI client with API URL: %s\n", config.APIURL)
+	fmt.Printf("DEBUG: Organization ID: %s\n", config.OrganizationID)
+	fmt.Printf("DEBUG: API key provided: %v\n", config.APIKey != "")
+	fmt.Printf("DEBUG: Timeout: %v\n", config.Timeout)
+
+	// Create a custom transport with specific timeouts and DNS configuration
+	dialer := &net.Dialer{
+		Timeout:   180 * time.Second,
+		KeepAlive: 180 * time.Second,
+		DualStack: true,
+	}
+
+	transport := &http.Transport{
+		Proxy:                 http.ProxyFromEnvironment,
+		DialContext:           dialer.DialContext,
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+		MaxIdleConnsPerHost:   10,
+	}
+
+	return &OpenAIClient{
+		APIKey:         config.APIKey,
+		OrganizationID: config.OrganizationID,
+		APIURL:         config.APIURL,
+		HTTPClient: &http.Client{
+			Transport: transport,
+			Timeout:   config.Timeout,
 		},
+		Timeout: config.Timeout,
 	}
 }
 
+// SetTimeout updates the timeout for the client
+func (c *OpenAIClient) SetTimeout(timeout time.Duration) {
+	c.Timeout = timeout
+	c.HTTPClient.Timeout = timeout
+}
+
 // Project represents a project in OpenAI
 type Project struct {
 	Object         string        `json:"object"`

internal/provider/provider.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"log"
 	"net/url"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -55,7 +56,13 @@ func GetOpenAIClientWithProjectKey(m interface{}) (*client.OpenAIClient, error)
 		// If project API key is available, create a new client with it
 		if c.ProjectAPIKey != "" {
 			log.Printf("[DEBUG] Using project API key for request")
-			return client.NewClient(c.ProjectAPIKey, c.OpenAIClient.OrganizationID, c.OpenAIClient.APIURL), nil
+			config := client.ClientConfig{
+				APIKey:         c.ProjectAPIKey,
+				OrganizationID: c.OpenAIClient.OrganizationID,
+				APIURL:         c.OpenAIClient.APIURL,
+				Timeout:        c.OpenAIClient.Timeout,
+			}
+			return client.NewClientWithConfig(config), nil
 		}
 		// Fall back to the default client if no project key
 		log.Printf("[DEBUG] No project API key available, using default client")
@@ -80,7 +87,13 @@ func GetOpenAIClientWithAdminKey(m interface{}) (*client.OpenAIClient, error) {
 		// If admin API key is available, create a new client with it
 		if c.AdminAPIKey != "" {
 			log.Printf("[DEBUG] Using admin API key for request")
-			return client.NewClient(c.AdminAPIKey, c.OpenAIClient.OrganizationID, c.OpenAIClient.APIURL), nil
+			config := client.ClientConfig{
+				APIKey:         c.AdminAPIKey,
+				OrganizationID: c.OpenAIClient.OrganizationID,
+				APIURL:         c.OpenAIClient.APIURL,
+				Timeout:        c.OpenAIClient.Timeout,
+			}
+			return client.NewClientWithConfig(config), nil
 		}
 		// Fall back to the project API key if no admin key
 		log.Printf("[DEBUG] No admin API key available, using project API key")
@@ -327,6 +340,12 @@ func Provider() *schema.Provider {
 				DefaultFunc: schema.EnvDefaultFunc("OPENAI_API_URL", "https://api.openai.com/v1"),
 				Description: "The URL for OpenAI API. If not set, the OPENAI_API_URL environment variable will be used, or the default value of 'https://api.openai.com/v1'.",
 			},
+			"timeout": {
+				Type:        schema.TypeInt,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("OPENAI_TIMEOUT", 300),
+				Description: "Timeout in seconds for API operations. If not set, the OPENAI_TIMEOUT environment variable will be used, or the default value of 300 seconds (5 minutes).",
+			},
 		},
 		ResourcesMap: resourceMap,
 		DataSourcesMap: map[string]*schema.Resource{
@@ -400,27 +419,37 @@ func providerConfigure(ctx context.Context, d *schema.ResourceData) (interface{}
 	adminKey := d.Get("admin_key").(string)
 	organization := d.Get("organization").(string)
 	apiURL := d.Get("api_url").(string)
+	timeout := d.Get("timeout").(int)
 
 	if apiURL == "" {
 		apiURL = defaultAPIURL
 	}
 
 	log.Printf("[DEBUG] Configuring provider with base URL: %s", apiURL)
 	log.Printf("[DEBUG] Organization ID: %s", organization)
+	log.Printf("[DEBUG] Timeout: %d seconds", timeout)
 
 	// Validate base URL
 	baseURL, err := url.Parse(apiURL)
 	if err != nil {
 		return nil, diag.Errorf("invalid API URL: %v", err)
 	}
 
+	// Create client configuration with timeout
+	config := client.ClientConfig{
+		APIKey:         apiKey,
+		OrganizationID: organization,
+		APIURL:         baseURL.String(),
+		Timeout:        time.Duration(timeout) * time.Second,
+	}
+
 	// Initialize OpenAI client with project API key by default
 	// The embedded client should use the project API key for standard operations
-	client := &OpenAIClient{
-		OpenAIClient:  client.NewClient(apiKey, organization, baseURL.String()),
+	providerClient := &OpenAIClient{
+		OpenAIClient:  client.NewClientWithConfig(config),
 		ProjectAPIKey: apiKey,
 		AdminAPIKey:   adminKey,
 	}
 
-	return client, nil
+	return providerClient, nil
 }

internal/provider/resource_openai_model_response.go

@@ -1,7 +1,6 @@
 package provider
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -250,76 +249,20 @@ func resourceOpenAIModelResponseCreate(ctx context.Context, d *schema.ResourceDa
 		fmt.Printf("[RESOURCE-DEBUG] Added store=true because stop sequences were provided\n")
 	}
 
-	// Usar directamente HTTP
-	fmt.Printf("[RESOURCE-DEBUG] Using direct HTTP approach\n")
+	// Use the client's DoRequest method
+	fmt.Printf("[RESOURCE-DEBUG] Using client DoRequest with timeout: %v\n", providerClient.Timeout)
 
-	// Create complete URL safely
-	baseURL := providerClient.APIURL
-	fmt.Printf("[RESOURCE-DEBUG] Original baseURL: %s\n", baseURL)
-
-	// Define the url variable
-	var url string
-
-	// Normalize: If base URL already contains /v1, don't add it again
-	if strings.HasSuffix(baseURL, "/v1") {
-		if !strings.HasSuffix(baseURL, "/") {
-			baseURL += "/"
-		}
-		url = baseURL + "responses"
-		fmt.Printf("[RESOURCE-DEBUG] URL with /v1 in base: %s\n", url)
-	} else {
-		// Standard case - need to add /v1
-		if !strings.HasSuffix(baseURL, "/") {
-			baseURL += "/"
-		}
-		url = baseURL + "v1/responses"
-		fmt.Printf("[RESOURCE-DEBUG] Standard URL: %s\n", url)
-	}
-
-	// Marshal the request body
-	jsonBody, err := json.Marshal(requestBody)
-	if err != nil {
-		fmt.Printf("[RESOURCE-DEBUG] Error marshaling request: %s\n", err)
-		return diag.Errorf("Error marshaling request: %s", err)
-	}
-
-	// Create the HTTP request
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
-	if err != nil {
-		fmt.Printf("[RESOURCE-DEBUG] Error creating request: %s\n", err)
-		return diag.Errorf("Error creating request: %s", err)
-	}
-
-	// Set headers
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", providerClient.APIKey))
-	if providerClient.OrganizationID != "" {
-		req.Header.Set("OpenAI-Organization", providerClient.OrganizationID)
-	}
-
-	// Make the HTTP request
-	fmt.Printf("[RESOURCE-DEBUG] Sending request to: %s\n", req.URL.String())
-	resp, err := providerClient.HTTPClient.Do(req)
+	// Use the /v1/responses endpoint
+	path := "/v1/responses"
+	
+	// Make the request using the client's method
+	respBody, err := providerClient.DoRequest("POST", path, requestBody)
 	if err != nil {
 		fmt.Printf("[RESOURCE-DEBUG] Error making request: %s\n", err)
 		return diag.Errorf("Error making request: %s", err)
 	}
-	defer resp.Body.Close()
-
-	// Read the response body
-	respBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Printf("[RESOURCE-DEBUG] Error reading response: %s\n", err)
-		return diag.Errorf("Error reading response: %s", err)
-	}
-
-	// Verify the status code
-	if resp.StatusCode >= 400 {
-		fmt.Printf("[RESOURCE-DEBUG] Error response: %d - %s\n", resp.StatusCode, string(respBody))
-		return diag.Errorf("API error: status code %d, body: %s", resp.StatusCode, string(respBody))
-	}
 
-	// Parse response as a map instead of using client.ModelResponse
+	// Parse response as a map
 	var responseMap map[string]interface{}
 	if err := json.Unmarshal(respBody, &responseMap); err != nil {
 		fmt.Printf("[RESOURCE-DEBUG] Error parsing response: %s\n", err)