pkg/inventory/inventory.go (1)

132-133: LGTM: DNSSimple provider integration

The new case properly integrates the DNSSimple provider into the provider factory. The implementation correctly passes the configuration block to the DNSSimple provider's New function.

Consider updating the Providers map (lines 53-75) to include DNSSimple services for consistency with other providers. This would allow users to list available DNSSimple services.

 var Providers = map[string][]string{
+	"dnssimple":    dnssimple.Services,
   // other providers...
 }

PROVIDERS.md (1)

410-428: LGTM: Well-documented DNSSimple provider configuration

The DNSSimple provider documentation follows the same format as other providers and includes:

• Clear configuration example
• Explanation of required credentials
• References to DNSSimple's documentation

Format URLs as markdown links for consistency with documentation standards:

 References - 
-1. https://developer.dnsimple.com/v2/
-2. https://support.dnsimple.com/articles/api-access-token/
+1. [DNSSimple API v2 Documentation](https://developer.dnsimple.com/v2/)
+2. [DNSSimple API Access Token Guide](https://support.dnsimple.com/articles/api-access-token/)

🧰 Tools

🪛 markdownlint-cli2 (0.17.2)

426-426: Bare URL used
null

(MD034, no-bare-urls)

---

427-427: Bare URL used
null

(MD034, no-bare-urls)

pkg/providers/dnssimple/dns.go (3)

44-46: Consider handling CNAME record content in the resource

Your filtering includes CNAME records, but the code doesn't capture or represent the CNAME target value. While you're correctly handling A and AAAA records by setting their IP addresses, CNAME records contain a hostname rather than an IP, which isn't being stored in the resource.

Consider adding specific handling for CNAME records:

// Set IP addresses based on record type
if record.Type == "A" {
    resource.PublicIPv4 = record.Content
} else if record.Type == "AAAA" {
    resource.PublicIPv6 = record.Content
+ } else if record.Type == "CNAME" {
+    // Store CNAME target in a field or perhaps as metadata
+    // Depending on schema.Resource capabilities, you might need to:
+    // resource.Metadata["cname_target"] = record.Content
}

---

26-35: Consider handling pagination for domain listings

The DNSSimple API likely implements pagination for accounts with many domains. While using DomainListOptions is correct, there doesn't appear to be any handling for retrieving results beyond the first page.

Consider implementing pagination handling:

// List all domains - using DomainListOptions instead of ListOptions
domainOptions := &dnsimple.DomainListOptions{}
- domains, err := d.client.Domains.ListDomains(ctx, d.account, domainOptions)
- if err != nil {
-     return nil, err
- }
+ var allDomains []dnsimple.Domain
+ 
+ // Handle pagination
+ for {
+     domains, err := d.client.Domains.ListDomains(ctx, d.account, domainOptions)
+     if err != nil {
+         return nil, err
+     }
+     
+     allDomains = append(allDomains, domains.Data...)
+     
+     // Check if we've reached the last page
+     if domains.Pagination.CurrentPage >= domains.Pagination.TotalPages {
+         break
+     }
+     
+     // Set up for next page
+     domainOptions.Page = domains.Pagination.NextPage
+ }

Similarly, you may want to implement the same pagination handling for the zone records retrieval.

---

37-40: Add error context when logging record retrieval failures

When logging errors for record retrieval failures, it would be helpful to include more context about why the failure occurred.

zoneRecords, err := d.client.Zones.ListRecords(ctx, d.account, domain.Name, recordOptions)
if err != nil {
-    log.Printf("Could not get records for domain %s: %s\n", domain.Name, err)
+    log.Printf("Could not get records for domain %s: %v (account: %s)\n", domain.Name, err, d.account)
    continue
}

pkg/providers/dnssimple/dnssimple.go (3)

80-91: Improve error handling in account ID retrieval

The account ID retrieval and error handling could be clarified and improved.

The current code properly checks for authentication errors and empty account information, but there's a blank line in the middle of the error return block (line 88-89) which should be removed. Also, consider providing more context in your error message about what the user should check.

// Get and store account ID
whoamiResponse, err := client.Identity.Whoami(context.Background())
if err != nil {
-   return nil, errorutil.NewWithErr(err).Msgf("failed to authenticate with DNSSimple")
+   return nil, errorutil.NewWithErr(err).Msgf("failed to authenticate with DNSSimple: check your API token validity")
}

if whoamiResponse.Data.Account == nil {
-   return nil, errorutil.New("no account information found in DNSSimple response")
-
+   return nil, errorutil.New("no account information found in DNSSimple response: your token may not have account access")
}

provider.account = fmt.Sprintf("%d", whoamiResponse.Data.Account.ID)

---

53-53: Consider adding client timeout configuration

The DNSSimple client is created without explicit timeout settings, which could lead to long-running connections in case of API issues.

// Set up the client
- client := dnsimple.NewClient(dnsimple.StaticTokenHTTPClient(context.Background(), token))
+ // Create context with timeout
+ clientCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+ client := dnsimple.NewClient(dnsimple.StaticTokenHTTPClient(clientCtx, token))

Don't forget to add the time package to your imports:

import (
    "context"
    "fmt"
    "strings"
+   "time"

    "github.com/dnsimple/dnsimple-go/dnsimple"
    // other imports...
)

---

44-94: Consider validating the token format before making API calls

Before making API calls, it would be beneficial to validate that the token format matches DNSSimple's requirements to provide better error messages.

func New(options schema.OptionBlock) (*Provider, error) {
    token, ok := options.GetMetadata(apiToken)
    if !ok {
        return nil, &schema.ErrNoSuchKey{Name: apiToken}
    }
+   // Basic validation of token format
+   token = strings.TrimSpace(token)
+   if token == "" {
+       return nil, errorutil.New("empty DNSSimple API token provided")
+   }
    
    id, _ := options.GetMetadata("id")
    
    // Rest of the function...
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro