feat: dns lookup source enhancements (#48869)

#### Description
1. Added A and AAAA lookups to DNS lookup source
2. Added configurable option to return multiple results if a single dns
resolution has multiple values.

#### Link to tracking issue
Planned enhancement which was mentioned in TODO list of the processor.

#### Testing
1. Unit tests added to test A and AAAA lookups.
2. Manual testing done, 
Ran the collector with new config to ensure all lookups work fine, 

[Test
config](https://github.com/user-attachments/files/28584515/dns-test-collector.yaml)

**Test data sent**: 
```
curl -s http://localhost:4318/v1/logs -X POST -H "Content-Type: application/json" -d '{
  "resourceLogs": [{
    "resource": {"attributes": [{"key": "service.name", "value": {"stringValue": "dns-lookup-test"}}]},
    "scopeLogs": [{
      "logRecords": [
        {
          "body": {"stringValue": "[PTR] resolve 8.8.8.8 -> hostname"},
          "attributes": [
            {"key": "client.ip",       "value": {"stringValue": "8.8.8.8"}},
            {"key": "target.hostname", "value": {"stringValue": "dns.google"}}
          ]
        }
      ]
    }]
  }]
}' 
```


**Collector debug log trace after enrichment:**
Shows all different supported lookups working on a single log line. 
Took client.ip from resource attribute and does a PTR lookup and
target.hostname was used to do A and AAAA lookups.

```
LogRecord #0
ObservedTimestamp: 1970-01-01 00:00:00 +0000 UTC
Timestamp: 1970-01-01 00:00:00 +0000 UTC
SeverityText: 
SeverityNumber: Unspecified(0)
Body: Str([PTR] resolve 8.8.8.8 -> hostname)
Attributes:
     -> client.ip: Str(8.8.8.8)
     -> target.hostname: Str(dns.google)
     -> client.hostname: Str(dns.google) // PTR lookup
     -> target.ipv4: Str(8.8.8.8) // A record lookup
     -> target.ipv6: Str(2001:4860:4860::8844) // AAAA record Lookup
Trace ID: 
Span ID: 
Flags: 0
        {"resource": {"service.instance.id": "3b8271db-6f06-484f-9737-7bf53bb3b53a", "service.name": "otelcol-custom", "service.version": "0.153.0-dev"}, "otelcol.component.id": "debug", "otelcol.component.kind": "exporter", "otelcol.signal": "logs"}
```
        
        


#### Documentation
Added relevant readme changes of dns source.


<!--Authorship attestation. See AGENTS.md for details. AI agents must
not check this box on behalf
of the user; the human author must check it themselves before the PR is
ready for review.-->
#### Authorship

- [x] I, a human, wrote this pull request description myself.

Author: jagan2221

.chloggen/lookup-processor-dns-lookup-enhacements.yaml

@@ -0,0 +1,22 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. receiver/filelog)
+component: processor/lookup
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add A and AAAA lookup support for dns source of lookup processor
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [48869]
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

processor/lookupprocessor/internal/source/dns/README.md

@@ -1,14 +1,15 @@
 # dns Source
 
-Performs reverse DNS lookups (PTR records) to resolve IP addresses to hostnames. Caching is enabled by default to minimize DNS queries.
+Performs DNS lookups supporting forward (A/AAAA) and reverse (PTR) record types. Caching is enabled by default to minimize DNS queries.
 
 ## Configuration
 
 | Field | Description | Default |
 | ----- | ----------- | ------- |
-| `record_type` | DNS record type (currently only `PTR` is supported) | `PTR` |
+| `record_type` | DNS record type: `PTR` (IP → hostname), `A` (hostname → IPv4), `AAAA` (hostname → IPv6) | `PTR` |
 | `timeout` | Maximum time to wait for DNS query (must be `> 0`) | `1s` |
 | `server` | DNS server to use (e.g., `8.8.8.8:53`). Empty uses system resolver | - |
+| `multiple_results` | Return all results as comma-separated string instead of just the first | `false` |
 | `cache.enabled` | Enable caching | `true` |
 | `cache.size` | Maximum cache entries (LRU eviction) | `10000` |
 | `cache.ttl` | Time-to-live for successful lookups | `5m` |
@@ -50,7 +51,5 @@ Cache hit is ~5,000x faster than a network lookup, with zero allocations.
 
 ## TODO
 
-- [ ] Support A record lookups (hostname to IPv4)
-- [ ] Support AAAA record lookups (hostname to IPv6)
 - [ ] Support TXT, CNAME, MX record lookups
 - [ ] Support multiple DNS servers

processor/lookupprocessor/internal/source/dns/dns.go

@@ -20,12 +20,20 @@ const sourceType = "dns"
 type RecordType string
 
 const (
-	// Only PTR for now.
+	// RecordTypePTR performs reverse DNS lookup (IP address to hostname).
 	RecordTypePTR RecordType = "PTR"
+	// RecordTypeA performs forward IPv4 DNS lookup (hostname to IPv4 address).
+	RecordTypeA RecordType = "A"
+	// RecordTypeAAAA performs forward IPv6 DNS lookup (hostname to IPv6 address).
+	RecordTypeAAAA RecordType = "AAAA"
 )
 
 type Config struct {
-	// RecordType specifies the DNS record type to look up.
+	// RecordType specifies the DNS record type to look up: "PTR", "A", or "AAAA".
+	// - PTR: reverse lookup, resolves IP address to hostname(s)
+	// - A: forward IPv4 lookup, resolves hostname to IPv4 address(es)
+	// - AAAA: forward IPv6 lookup, resolves hostname to IPv6 address(es)
+	// Default: "PTR"
 	RecordType RecordType `mapstructure:"record_type"`
 
 	// Timeout is the maximum time to wait for a DNS query.
@@ -36,6 +44,11 @@ type Config struct {
 	// If empty, uses the system resolver.
 	Server string `mapstructure:"server"`
 
+	// MultipleResults specifies whether to return all DNS results or just the first.
+	// If true, multiple results are returned as a comma-separated string.
+	// Default: false
+	MultipleResults bool `mapstructure:"multiple_results"`
+
 	// Cache configures caching for DNS lookups.
 	// Enabled by default.
 	// Disabling is not recommended due to potential performance impact.
@@ -44,10 +57,10 @@ type Config struct {
 
 func (c *Config) Validate() error {
 	switch c.RecordType {
-	case "", RecordTypePTR:
+	case "", RecordTypePTR, RecordTypeA, RecordTypeAAAA:
 		// Valid
 	default:
-		return fmt.Errorf("invalid record_type %q, only PTR is currently supported", c.RecordType)
+		return fmt.Errorf("invalid record_type %q, must be one of: PTR, A, AAAA", c.RecordType)
 	}
 
 	if c.Timeout <= 0 {
@@ -110,9 +123,10 @@ func createSource(
 	}
 
 	s := &dnsSource{
-		recordType: recordType,
-		timeout:    timeout,
-		resolver:   resolver,
+		recordType:      recordType,
+		timeout:         timeout,
+		resolver:        resolver,
+		multipleResults: dnsCfg.MultipleResults,
 	}
 
 	// Create the lookup function, optionally wrapped with cache
@@ -131,16 +145,57 @@ func createSource(
 }
 
 type dnsSource struct {
-	recordType RecordType
-	timeout    time.Duration
-	resolver   *net.Resolver
+	recordType      RecordType
+	timeout         time.Duration
+	resolver        *net.Resolver
+	multipleResults bool
 }
 
 func (s *dnsSource) lookup(ctx context.Context, key string) (any, bool, error) {
 	ctx, cancel := context.WithTimeout(ctx, s.timeout)
 	defer cancel()
-	// Currently only PTR is supported
-	return s.lookupPTR(ctx, key)
+	switch s.recordType {
+	case RecordTypeA, RecordTypeAAAA:
+		return s.lookupForward(ctx, key)
+	default:
+		return s.lookupPTR(ctx, key)
+	}
+}
+
+// lookupForward performs forward DNS lookup (hostname -> IP addresses).
+func (s *dnsSource) lookupForward(ctx context.Context, hostname string) (any, bool, error) {
+	addrs, err := s.resolver.LookupIPAddr(ctx, hostname)
+	if err != nil {
+		var dnsErr *net.DNSError
+		if errors.As(err, &dnsErr) && (dnsErr.IsNotFound || dnsErr.IsTemporary) {
+			return nil, false, nil
+		}
+		return nil, false, err
+	}
+
+	if len(addrs) == 0 {
+		return nil, false, nil
+	}
+
+	var ips []string
+	for _, addr := range addrs {
+		if s.recordType == RecordTypeA && addr.IP.To4() != nil {
+			// IPv4 address for A record
+			ips = append(ips, addr.IP.String())
+		} else if s.recordType == RecordTypeAAAA && addr.IP.To4() == nil && addr.IP.To16() != nil {
+			// IPv6 address for AAAA record
+			ips = append(ips, addr.IP.String())
+		}
+	}
+
+	if len(ips) == 0 {
+		return nil, false, nil
+	}
+
+	if s.multipleResults {
+		return strings.Join(ips, ","), true, nil
+	}
+	return ips[0], true, nil
 }
 
 // lookupPTR performs reverse DNS lookup (IP -> hostname).
@@ -159,6 +214,13 @@ func (s *dnsSource) lookupPTR(ctx context.Context, ip string) (any, bool, error)
 		return nil, false, nil
 	}
 
-	// Return the first hostname, trimming trailing dot
-	return strings.TrimSuffix(names[0], "."), true, nil
+	// Trim trailing dots from PTR records
+	for i := range names {
+		names[i] = strings.TrimSuffix(names[i], ".")
+	}
+
+	if s.multipleResults {
+		return strings.Join(names, ","), true, nil
+	}
+	return names[0], true, nil
 }

processor/lookupprocessor/internal/source/dns/dns_test.go

@@ -6,6 +6,7 @@ package dns
 import (
 	"net"
 	"runtime"
+	"strings"
 	"testing"
 	"time"
 
@@ -41,16 +42,26 @@ func TestConfigValidate(t *testing.T) {
 			wantErr: false,
 		},
 		{
-			name: "unsupported record type",
+			name: "A record type",
 			config: &Config{
-				RecordType: "A",
+				RecordType: RecordTypeA,
+				Timeout:    1 * time.Second,
 			},
-			wantErr: true,
+			wantErr: false,
+		},
+		{
+			name: "AAAA record type",
+			config: &Config{
+				RecordType: RecordTypeAAAA,
+				Timeout:    1 * time.Second,
+			},
+			wantErr: false,
 		},
 		{
 			name: "invalid record type",
 			config: &Config{
 				RecordType: "INVALID",
+				Timeout:    1 * time.Second,
 			},
 			wantErr: true,
 		},
@@ -143,6 +154,111 @@ func TestDefaultConfig(t *testing.T) {
 // Integration tests - these actually perform DNS lookups
 // They're skipped in CI but useful for local development
 
+func TestLookupA_Integration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test in short mode")
+	}
+
+	factory := NewFactory()
+	cfg := &Config{
+		RecordType: RecordTypeA,
+		Timeout:    5 * time.Second,
+		Cache: lookupsource.CacheConfig{
+			Enabled: false,
+		},
+	}
+
+	source, err := factory.CreateSource(t.Context(), lookupsource.CreateSettings{}, cfg)
+	require.NoError(t, err)
+
+	val, found, err := source.Lookup(t.Context(), "dns.google")
+	require.NoError(t, err)
+
+	if found {
+		ip, ok := val.(string)
+		assert.True(t, ok)
+		// A record should be an IPv4 address (contains dots, no colons)
+		assert.Contains(t, ip, ".")
+		assert.NotContains(t, ip, ":")
+		t.Logf("A lookup for dns.google: %s", ip)
+	} else {
+		t.Log("A lookup for dns.google not found (may be network issue)")
+	}
+}
+
+func TestLookupAAAA_Integration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test in short mode")
+	}
+
+	factory := NewFactory()
+	cfg := &Config{
+		RecordType: RecordTypeAAAA,
+		Timeout:    5 * time.Second,
+		Cache: lookupsource.CacheConfig{
+			Enabled: false,
+		},
+	}
+
+	source, err := factory.CreateSource(t.Context(), lookupsource.CreateSettings{}, cfg)
+	require.NoError(t, err)
+
+	val, found, err := source.Lookup(t.Context(), "dns.google")
+	require.NoError(t, err)
+
+	if found {
+		ip, ok := val.(string)
+		assert.True(t, ok)
+		// AAAA record should be an IPv6 address (contains colons)
+		assert.Contains(t, ip, ":")
+		t.Logf("AAAA lookup for dns.google: %s", ip)
+	} else {
+		t.Log("AAAA lookup for dns.google not found (may be network issue or no IPv6)")
+	}
+}
+
+func TestLookupA_MultipleResults_Integration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test in short mode")
+	}
+
+	factory := NewFactory()
+	cfg := &Config{
+		RecordType:      RecordTypeA,
+		Timeout:         5 * time.Second,
+		MultipleResults: true,
+		Cache: lookupsource.CacheConfig{
+			Enabled: false,
+		},
+	}
+
+	source, err := factory.CreateSource(t.Context(), lookupsource.CreateSettings{}, cfg)
+	require.NoError(t, err)
+
+	val, found, err := source.Lookup(t.Context(), "dns.google")
+	require.NoError(t, err)
+
+	if !found {
+		t.Skip("A lookup for dns.google not found (may be network issue)")
+	}
+
+	result, ok := val.(string)
+	require.True(t, ok)
+
+	// Multiple results must be comma-separated
+	ips := strings.Split(result, ",")
+	assert.Greater(t, len(ips), 1, "expected multiple IPs but got single result %q — MultipleResults may not be working", result)
+
+	// Each entry must be a valid IPv4 address (no colons)
+	for _, ip := range ips {
+		ip = strings.TrimSpace(ip)
+		assert.NotEmpty(t, ip)
+		assert.Contains(t, ip, ".", "expected IPv4 address, got %q", ip)
+		assert.NotContains(t, ip, ":", "A record should not return IPv6 addresses, got %q", ip)
+	}
+	t.Logf("A multiple ipv4 results for dns.google (%d IPs): %s", len(ips), result)
+}
+
 func TestLookupPTR_Integration(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")