Infer OpenCensus resource type based on OpenTelemetry's semantic conventions

translator/internaldata/resource_to_oc.go

@@ -23,11 +23,45 @@ import (
 	occommon "github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1"
 	ocresource "github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1"
 	"github.com/golang/protobuf/ptypes"
+	"go.opencensus.io/resource/resourcekeys"
 
 	"go.opentelemetry.io/collector/consumer/pdata"
 	"go.opentelemetry.io/collector/translator/conventions"
 )
 
+type ocResourceTypeDetector struct {
+	// label presence to check against
+	labelKey string
+	// matching resource type
+	resourceType string
+}
+
+// mapping of label presence to inferred OC resource type
+// NOTE: defined in the priority order (first match wins)
+var attributeToResourceType = []ocResourceTypeDetector{
+	{
+		// See https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/resource/semantic_conventions/container.md
+		labelKey:     conventions.AttributeContainerName,
+		resourceType: resourcekeys.ContainerType,
+	},
+	{
+		// See https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/resource/semantic_conventions/k8s.md#pod
+		labelKey: conventions.AttributeK8sPod,
+		// NOTE: OpenCensus is using "k8s" rather than "k8s.pod" for Pod
+		resourceType: resourcekeys.K8SType,
+	},
+	{
+		// See https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/resource/semantic_conventions/host.md
+		labelKey:     conventions.AttributeHostName,
+		resourceType: resourcekeys.HostType,
+	},
+	{
+		// See https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/resource/semantic_conventions/cloud.md
+		labelKey:     conventions.AttributeCloudProvider,
+		resourceType: resourcekeys.CloudType,
+	},
+}
+
 func internalResourceToOC(resource pdata.Resource) (*occommon.Node, *ocresource.Resource) {
 	if resource.IsNil() {
 		return nil, nil
@@ -104,6 +138,14 @@ func internalResourceToOC(resource pdata.Resource) (*occommon.Node, *ocresource.
 	})
 	ocResource.Labels = labels
 
+	// If resource type is missing, try to infer it
+	// based on the presence of resource labels (semantic conventions)
+	if ocResource.Type == "" {
+		if resType, ok := inferResourceType(ocResource.Labels); ok {
+			ocResource.Type = resType
+		}
+	}
+
 	return &ocNode, &ocResource
 }
 
@@ -152,3 +194,17 @@ func attributeValueToString(attr pdata.AttributeValue, jsonLike bool) string {
 
 	// TODO: Add support for ARRAY type.
 }
+
+func inferResourceType(labels map[string]string) (string, bool) {
+	if labels == nil {
+		return "", false
+	}
+
+	for _, detector := range attributeToResourceType {
+		if _, ok := labels[detector.labelKey]; ok {
+			return detector.resourceType, true
+		}
+	}
+
+	return "", false
+}

translator/internaldata/resource_to_oc_test.go

@@ -21,6 +21,8 @@ import (
 	agenttracepb "github.com/census-instrumentation/opencensus-proto/gen-go/agent/trace/v1"
 	ocresource "github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1"
 	"github.com/stretchr/testify/assert"
+	"go.opencensus.io/resource/resourcekeys"
+	"go.opentelemetry.io/collector/translator/conventions"
 	"google.golang.org/protobuf/proto"
 
 	"go.opentelemetry.io/collector/consumer/pdata"
@@ -90,6 +92,78 @@ func TestAttributeValueToString(t *testing.T) {
 	assert.EqualValues(t, `{"a\"\\":"b\"\\","c":123,"d":null,"e":{"a\"\\":"b\"\\","c":123,"d":null}}`, attributeValueToString(v, false))
 }
 
+func TestInferResourceType(t *testing.T) {
+	tests := []struct {
+		name             string
+		labels           map[string]string
+		wantResourceType string
+		wantOk           bool
+	}{
+		{
+			name:   "empty labels",
+			labels: nil,
+			wantOk: false,
+		},
+		{
+			name: "container",
+			labels: map[string]string{
+				conventions.AttributeK8sCluster:    "cluster1",
+				conventions.AttributeK8sPod:        "pod1",
+				conventions.AttributeK8sNamespace:  "namespace1",
+				conventions.AttributeContainerName: "container-name1",
+				conventions.AttributeCloudAccount:  "proj1",
+				conventions.AttributeCloudZone:     "zone1",
+			},
+			wantResourceType: resourcekeys.ContainerType,
+			wantOk:           true,
+		},
+		{
+			name: "pod",
+			labels: map[string]string{
+				conventions.AttributeK8sCluster:   "cluster1",
+				conventions.AttributeK8sPod:       "pod1",
+				conventions.AttributeK8sNamespace: "namespace1",
+				conventions.AttributeCloudZone:    "zone1",
+			},
+			wantResourceType: resourcekeys.K8SType,
+			wantOk:           true,
+		},
+		{
+			name: "host",
+			labels: map[string]string{
+				conventions.AttributeK8sCluster: "cluster1",
+				conventions.AttributeCloudZone:  "zone1",
+				conventions.AttributeHostName:   "node1",
+			},
+			wantResourceType: resourcekeys.HostType,
+			wantOk:           true,
+		},
+		{
+			name: "gce",
+			labels: map[string]string{
+				conventions.AttributeCloudProvider: "gcp",
+				conventions.AttributeHostID:        "inst1",
+				conventions.AttributeCloudZone:     "zone1",
+			},
+			wantResourceType: resourcekeys.CloudType,
+			wantOk:           true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			resourceType, ok := inferResourceType(tc.labels)
+			if tc.wantOk {
+				assert.True(t, ok)
+				assert.Equal(t, tc.wantResourceType, resourceType)
+			} else {
+				assert.False(t, ok)
+				assert.Equal(t, "", resourceType)
+			}
+		})
+	}
+}
+
 func BenchmarkInternalResourceToOC(b *testing.B) {
 	resource := generateResourceWithOcNodeAndResource()