Extract db.namespace from DSN in AttributesFromDSN

CHANGELOG.md

@@ -8,6 +8,11 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Added
+
+- `AttributesFromDSN` now extracts the database name from the DSN and sets it as the `db.namespace` attribute 
+  ([`semconv.DBNamespaceKey`](https://opentelemetry.io/docs/specs/semconv/database/database-spans/#common-attributes)). [#608](https://github.com/XSAM/otelsql/pull/608)
+
 ## [0.42.0] - 2026-03-30
 
 ### ⚠️ Notice ⚠️

helpers.go

@@ -24,8 +24,34 @@ import (
 )
 
 // AttributesFromDSN returns attributes extracted from a DSN string.
-// It makes the best effort to retrieve values for [semconv.ServerAddressKey] and [semconv.ServerPortKey].
+// It makes the best effort to retrieve values for
+// [semconv.ServerAddressKey], [semconv.ServerPortKey], and [semconv.DBNamespaceKey].
 func AttributesFromDSN(dsn string) []attribute.KeyValue {
+	serverAddress, serverPort, dbName := parseDSN(dsn)
+
+	var attrs []attribute.KeyValue
+
+	if serverAddress != "" {
+		attrs = append(attrs, semconv.ServerAddress(serverAddress))
+	}
+
+	if serverPort != -1 {
+		attrs = append(attrs, semconv.ServerPortKey.Int64(serverPort))
+	}
+
+	if dbName != "" {
+		attrs = append(attrs, semconv.DBNamespace(dbName))
+	}
+
+	return attrs
+}
+
+// parseDSN parses a DSN string and returns the server address, server port, and database name.
+// It handles the format: [scheme://][user[:password]@][protocol([addr])]/dbname[?params]
+// serverAddress and dbName are empty strings if not found. serverPort is -1 if not found.
+func parseDSN(dsn string) (serverAddress string, serverPort int64, dbName string) {
+	serverPort = -1
+
 	// [scheme://][user[:password]@][protocol([addr])]/dbname[?param1=value1&paramN=valueN]
 	// Find the schema part.
 	schemaIndex := strings.Index(dsn, "://")
@@ -47,38 +73,46 @@ func AttributesFromDSN(dsn string) []attribute.KeyValue {
 	pathIndex := strings.Index(dsn, "/")
 	if pathIndex != -1 {
 		// Remove the path part from the DSN.
+		path := dsn[pathIndex+1:]
+		// dbname[?param1=value1&paramN=valueN]
+		if questionMarkIndex := strings.Index(path, "?"); questionMarkIndex != -1 {
+			path = path[:questionMarkIndex]
+		}
+		// Extract db name
+		dbName = path
+		// [protocol([addr])] or [addr]
 		dsn = dsn[:pathIndex]
 	}
 
 	// [protocol([addr])] or [addr]
 	// Find the '(' that starts the address part.
 	openParen := strings.Index(dsn, "(")
 	if openParen != -1 {
+		rest := dsn[openParen+1:]
+		if closeParen := strings.Index(rest, ")"); closeParen != -1 {
+			rest = rest[:closeParen]
+		}
 		// Remove the protocol part from the DSN.
-		dsn = dsn[openParen+1 : len(dsn)-1]
+		dsn = rest
 	}
 
 	// [addr]
 	if len(dsn) == 0 {
-		return nil
+		return serverAddress, serverPort, dbName
 	}
 
+	// Extract host and port
 	host, portStr, err := net.SplitHostPort(dsn)
 	if err != nil {
-		host = dsn
+		serverAddress = dsn
+		return serverAddress, serverPort, dbName
 	}
 
-	attrs := make([]attribute.KeyValue, 0, 2)
-	if host != "" {
-		attrs = append(attrs, semconv.ServerAddress(host))
-	}
+	serverAddress = host
 
-	if portStr != "" {
-		port, err := strconv.ParseInt(portStr, 10, 64)
-		if err == nil {
-			attrs = append(attrs, semconv.ServerPortKey.Int64(port))
-		}
+	if port, err := strconv.ParseInt(portStr, 10, 64); err == nil {
+		serverPort = port
 	}
 
-	return attrs
+	return serverAddress, serverPort, dbName
 }

helpers_test.go

@@ -28,60 +28,77 @@ func TestAttributesFromDSN(t *testing.T) {
 		dsn      string
 		expected []attribute.KeyValue
 	}{
+		{
+			dsn: "mysql://root:otel_password@example.com/db",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("example.com"),
+				semconv.DBNamespace("db"),
+			},
+		},
 		{
 			dsn: "mysql://root:otel_password@tcp(example.com)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("example.com"),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "mysql://root:otel_password@tcp(example.com:3307)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("example.com"),
 				semconv.ServerPort(3307),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "mysql://root:otel_password@tcp([2001:db8:1234:5678:9abc:def0:0001]:3307)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("2001:db8:1234:5678:9abc:def0:0001"),
 				semconv.ServerPort(3307),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "mysql://root:otel_password@tcp(2001:db8:1234:5678:9abc:def0:0001)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("2001:db8:1234:5678:9abc:def0:0001"),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "root:secret@tcp(mysql)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("mysql"),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "root:secret@tcp(mysql:3307)/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("mysql"),
 				semconv.ServerPort(3307),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
-			dsn:      "root:secret@/db?parseTime=true",
-			expected: nil,
+			dsn: "root:secret@/db?parseTime=true",
+			expected: []attribute.KeyValue{
+				semconv.DBNamespace("db"),
+			},
 		},
 		{
 			dsn: "example.com/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("example.com"),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "example.com:3307/db?parseTime=true",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("example.com"),
 				semconv.ServerPort(3307),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
@@ -103,38 +120,79 @@ func TestAttributesFromDSN(t *testing.T) {
 				semconv.ServerAddress("example.com"),
 			},
 		},
+		{
+			dsn: "example.com/db",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("example.com"),
+				semconv.DBNamespace("db"),
+			},
+		},
 		{
 			dsn: "postgres://root:secret@0.0.0.0:42/db?param1=value1&paramN=valueN",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("0.0.0.0"),
 				semconv.ServerPort(42),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "postgres://root:secret@2001:db8:1234:5678:9abc:def0:0001/db?param1=value1&paramN=valueN",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("2001:db8:1234:5678:9abc:def0:0001"),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "postgres://root:secret@[2001:db8:1234:5678:9abc:def0:0001]:42/db?param1=value1&paramN=valueN",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("2001:db8:1234:5678:9abc:def0:0001"),
 				semconv.ServerPort(42),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			dsn: "root:secret@0.0.0.0:42/db?param1=value1&paramN=valueN",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("0.0.0.0"),
 				semconv.ServerPort(42),
+				semconv.DBNamespace("db"),
 			},
 		},
 		{
 			// In this case, "tcp" will be considered as the server address.
 			dsn: "root:secret@tcp/db?param1=value1&paramN=valueN",
 			expected: []attribute.KeyValue{
 				semconv.ServerAddress("tcp"),
+				semconv.DBNamespace("db"),
+			},
+		},
+		{
+			// DSN lacking a db-name
+			dsn: "sqlserver://user:pass@dbhost:1433",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("dbhost"),
+				semconv.ServerPort(1433),
+			},
+		},
+		{
+			// DSN lacking a db-name, with trailing '/'
+			dsn: "postgres://user:pass@dbhost/",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("dbhost"),
+			},
+		},
+		{
+			dsn: "unknown://user:pass@dbhost/db",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("dbhost"),
+				semconv.DBNamespace("db"),
+			},
+		},
+		{
+			// malformed DSN shouldn't fail
+			dsn: "root:pass@tcp(dbhost",
+			expected: []attribute.KeyValue{
+				semconv.ServerAddress("dbhost"),
 			},
 		},
 	}