Merge pull request #347 from bryce-b/LoggingSDK

Author: Ignacio Bonafonte

Examples/OTLP Exporter/main.swift

@@ -40,7 +40,7 @@ let spanExporter = MultiSpanExporter(spanExporters: [otlpTraceExporter, stdoutEx
 let spanProcessor = SimpleSpanProcessor(spanExporter: spanExporter)
 OpenTelemetrySDK.instance.tracerProvider.addSpanProcessor(spanProcessor)
 
-if #available(macOS 10.14, *) {
+if #available(macOS 10.14, *), #available(iOS 12.0, *) {
     OpenTelemetrySDK.instance.tracerProvider.addSpanProcessor(SignPostIntegration())
 }
 

Sources/Exporters/OpenTelemetryProtocol/logs/LogRecordAdapter.swift

@@ -0,0 +1,75 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+import OpenTelemetryApi
+import OpenTelemetrySdk
+public class LogRecordAdapter {
+    public static func toProtoResourceRecordLog(logRecordList: [ReadableLogRecord]) -> [Opentelemetry_Proto_Logs_V1_ResourceLogs] {
+       let resourceAndScopeMap = groupByResourceAndScope(logRecordList: logRecordList)
+        var resourceLogs = [Opentelemetry_Proto_Logs_V1_ResourceLogs]()
+         resourceAndScopeMap.forEach { resMap in
+             var scopeLogs = [Opentelemetry_Proto_Logs_V1_ScopeLogs]()
+             resMap.value.forEach { scopeInfo, logRecords in
+                var protoScopeLogs = Opentelemetry_Proto_Logs_V1_ScopeLogs()
+                 protoScopeLogs.scope = CommonAdapter.toProtoInstrumentationScope(instrumentationScopeInfo: scopeInfo)
+                 logRecords.forEach { record in
+                    protoScopeLogs.logRecords.append(record)
+                 }
+                 scopeLogs.append(protoScopeLogs)
+             }
+             var resourceLog = Opentelemetry_Proto_Logs_V1_ResourceLogs()
+             resourceLog.resource = ResourceAdapter.toProtoResource(resource: resMap.key)
+             resourceLog.scopeLogs.append(contentsOf: scopeLogs)
+             resourceLogs.append(resourceLog)
+        }
+        return resourceLogs
+    }
+
+        public static func groupByResourceAndScope(logRecordList: [ReadableLogRecord]) -> [Resource:[InstrumentationScopeInfo:[Opentelemetry_Proto_Logs_V1_LogRecord]]] {
+            var result = [Resource:[InstrumentationScopeInfo: [Opentelemetry_Proto_Logs_V1_LogRecord]]]()
+            logRecordList.forEach { logRecord in
+                result[logRecord.resource, default:[InstrumentationScopeInfo: [Opentelemetry_Proto_Logs_V1_LogRecord]]()][logRecord.instrumentationScopeInfo,default:[Opentelemetry_Proto_Logs_V1_LogRecord]()].append(toProtoLogRecord(logRecord: logRecord))
+            }
+            return result
+        }
+
+    public static func toProtoLogRecord(logRecord: ReadableLogRecord) -> Opentelemetry_Proto_Logs_V1_LogRecord {
+        var protoLogRecord = Opentelemetry_Proto_Logs_V1_LogRecord()
+        
+        if let observedTimestamp = logRecord.observedTimestamp {
+            protoLogRecord.observedTimeUnixNano = observedTimestamp.timeIntervalSince1970.toNanoseconds
+        }
+        
+        protoLogRecord.timeUnixNano = logRecord.timestamp.timeIntervalSince1970.toNanoseconds
+        
+        if let body = logRecord.body, !body.isEmpty {
+            var protoBody = Opentelemetry_Proto_Common_V1_AnyValue()
+            protoBody.stringValue = body
+            protoLogRecord.body = protoBody
+        }
+        
+        
+        if let severity = logRecord.severity {
+            protoLogRecord.severityText = severity.description
+            if let protoSeverity = Opentelemetry_Proto_Logs_V1_SeverityNumber(rawValue: severity.rawValue) {
+                protoLogRecord.severityNumber = protoSeverity
+            }
+        }
+
+        if let context = logRecord.spanContext {
+            protoLogRecord.spanID = TraceProtoUtils.toProtoSpanId(spanId: context.spanId)
+            protoLogRecord.traceID = TraceProtoUtils.toProtoTraceId(traceId: context.traceId)
+            protoLogRecord.flags = UInt32(context.traceFlags.byte)
+        }
+        
+        var protoAttributes = [Opentelemetry_Proto_Common_V1_KeyValue]()
+        logRecord.attributes.forEach { key, value in
+            protoAttributes.append(CommonAdapter.toProtoAttribute(key: key, attributeValue: value))
+        }
+        protoLogRecord.attributes = protoAttributes
+        return protoLogRecord
+    }
+}

Sources/Exporters/OpenTelemetryProtocol/logs/OtlpLogExporter.swift

@@ -0,0 +1,57 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+import Logging
+import GRPC
+import NIO
+import NIOHPACK
+import OpenTelemetryApi
+import OpenTelemetrySdk
+
+public class OtlpLogExporter : LogRecordExporter {
+    let channel : GRPCChannel
+    var logClient : Opentelemetry_Proto_Collector_Logs_V1_LogsServiceNIOClient
+    let config : OtlpConfiguration
+    var callOptions : CallOptions? = nil
+
+    public init(channel: GRPCChannel,
+                config: OtlpConfiguration = OtlpConfiguration(),
+                logger: Logging.Logger = Logging.Logger(label: "io.grpc", factory: { _ in SwiftLogNoOpLogHandler() }),
+                envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes){
+        self.channel = channel
+        logClient = Opentelemetry_Proto_Collector_Logs_V1_LogsServiceNIOClient(channel: channel)
+        self.config = config
+        if let headers = envVarHeaders {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers), logger: logger)
+        } else if let headers = config.headers {
+            callOptions = CallOptions(customMetadata: HPACKHeaders(headers), logger: logger)
+        }
+        else {
+            callOptions = CallOptions(logger: logger)
+        }
+    }
+
+    public func export(logRecords: [ReadableLogRecord]) -> ExportResult {
+        let logRequest = Opentelemetry_Proto_Collector_Logs_V1_ExportLogsServiceRequest.with { request in
+            request.resourceLogs = LogRecordAdapter.toProtoResourceRecordLog(logRecordList: logRecords)
+        }
+        let export = logClient.export(logRequest, callOptions: callOptions)
+        do {
+            _ = try export.response.wait()
+            return .success
+        } catch {
+            return .failure
+        }
+    }
+
+    public func shutdown() {
+        _ = channel.close()
+    }
+
+    public func forceFlush() -> ExportResult {
+        .success
+    }
+}

Sources/Exporters/OpenTelemetryProtocol/metric/OtlpMetricExporter.swift

@@ -19,7 +19,7 @@ public class OtlpMetricExporter: MetricExporter {
 
 
 
-    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration(), logger: Logger = Logger(label: "io.grpc", factory: { _ in SwiftLogNoOpLogHandler() }), envVarHeaders: [(String,String)]? = EnvVarHeaders.attributes) {
+    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration(), logger: Logging.Logger = Logging.Logger(label: "io.grpc", factory: { _ in SwiftLogNoOpLogHandler() }), envVarHeaders: [(String,String)]? = EnvVarHeaders.attributes) {
         self.channel = channel
         self.config = config
         self.metricClient = Opentelemetry_Proto_Collector_Metrics_V1_MetricsServiceNIOClient(channel: self.channel)

Sources/Exporters/OpenTelemetryProtocol/trace/OtlpTraceExporter.swift

@@ -17,7 +17,7 @@ public class OtlpTraceExporter: SpanExporter {
     let config : OtlpConfiguration
     var callOptions : CallOptions? = nil
 
-    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration(), logger: Logger = Logger(label: "io.grpc", factory: { _ in SwiftLogNoOpLogHandler() }), envVarHeaders: [(String,String)]? = EnvVarHeaders.attributes) {
+    public init(channel: GRPCChannel, config: OtlpConfiguration = OtlpConfiguration(), logger: Logging.Logger = Logging.Logger(label: "io.grpc", factory: { _ in SwiftLogNoOpLogHandler() }), envVarHeaders: [(String,String)]? = EnvVarHeaders.attributes) {
         self.channel = channel
         traceClient = Opentelemetry_Proto_Collector_Trace_V1_TraceServiceNIOClient(channel: channel)
         self.config = config

Sources/Instrumentation/URLSession/README.md

@@ -25,6 +25,6 @@ This behaviour can be modified or augmented by using the optional callbacks defi
 
 `receivedResponse: ((URLResponse, DataOrFile?, Span) -> Void)?`- Called after response is received,  it allows to add extra information to the Span
 
-`receivedError: ((Error, DataOrFile?, HTTPStatus, Span) -> Void)?` -  Called after an errror is received,  it allows to add extra information to the Span
+`receivedError: ((Error, DataOrFile?, HTTPStatus, Span) -> Void)?` -  Called after an error is received,  it allows to add extra information to the Span
 
 

Sources/OpenTelemetryApi/Logs/DefaultLogger.swift

@@ -0,0 +1,67 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+
+public class DefaultLogger : Logger {
+
+    private static let instanceWithDomain = DefaultLogger(true)
+    private static let instanceNoDomain = DefaultLogger(false)
+    private static let noopLogRecordBuilder = NoopLogRecordBuilder()
+
+    private var hasDomain : Bool
+
+    private init(_ hasDomain : Bool) {
+        self.hasDomain = hasDomain
+    }
+
+    static func getInstance(_ hasDomain: Bool) -> Logger {
+        if hasDomain {
+            return Self.instanceWithDomain
+        } else {
+            return Self.instanceNoDomain
+        }
+    }
+
+    public func eventBuilder(name: String) -> EventBuilder {
+        if !hasDomain {
+            /// log error
+        }
+        return Self.noopLogRecordBuilder
+    }
+
+    public func logRecordBuilder() -> LogRecordBuilder {
+        return Self.noopLogRecordBuilder
+    }
+
+    private class NoopLogRecordBuilder : EventBuilder {
+
+        func setObservedTimestamp(_ observed: Date) -> Self {
+            return self
+        }
+
+        func setSpanContext(_ context: SpanContext) -> Self {
+            return self
+        }
+
+        func setSeverity(_ severity: Severity) -> Self {
+            return self
+        }
+
+        func setBody(_ body: String) -> Self {
+            return self
+        }
+
+        func setAttributes(_ attributes: [String: AttributeValue]) -> Self {
+            return self
+        }
+
+        func emit() {
+
+        }
+
+    }
+
+}

Sources/OpenTelemetryApi/Logs/DefaultLoggerProvider.swift

@@ -0,0 +1,55 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+
+public class DefaultLoggerProvider : LoggerProvider {
+    public static let instance: LoggerProvider = DefaultLoggerProvider()
+    fileprivate static let noopBuilderWithDomain = NoopLoggerBuilder(true)
+    fileprivate static let noopBuilderNoDomain = NoopLoggerBuilder(false)
+
+    public func get(instrumentationScopeName: String) -> Logger {
+        return loggerBuilder(instrumentationScopeName: instrumentationScopeName).build()
+    }
+
+    public func loggerBuilder(instrumentationScopeName: String) -> LoggerBuilder {
+        return Self.noopBuilderNoDomain
+    }
+}
+
+fileprivate class NoopLoggerBuilder: LoggerBuilder {
+    private let hasDomain : Bool
+
+    fileprivate init(_ hasDomain: Bool) {
+        self.hasDomain = hasDomain
+    }
+
+    public func setEventDomain(_ eventDomain: String) -> Self {
+        if eventDomain.isEmpty {
+            return DefaultLoggerProvider.noopBuilderNoDomain as! Self
+        }
+        return DefaultLoggerProvider.noopBuilderWithDomain as! Self
+    }
+
+    public func setSchemaUrl(_ schemaUrl: String) -> Self {
+        return self
+    }
+
+    public func setInstrumentationVersion(_ instrumentationVersion: String) -> Self {
+        return self
+    }
+
+    public func setIncludeTraceContext(_ includeTraceContext: Bool) -> Self {
+        return self
+    }
+
+    public func setAttributes(_ attributes: [String: AttributeValue]) -> Self {
+        return self
+    }
+
+    public func build() -> Logger {
+        return DefaultLogger.getInstance(hasDomain)
+    }
+}

Sources/OpenTelemetryApi/Logs/EventBuilder.swift

@@ -0,0 +1,15 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+
+/// Used to construct and emit events from a Logger.
+///
+/// An event is a LogRecord with attributes for `event.domain` and `event.name`.
+///
+/// Obtain an Logger.eventBuilder(name: String), add properties using the stters, and emit
+/// the LogRecord by calling `emit()`
+public protocol EventBuilder : LogRecordBuilder {
+}

Sources/OpenTelemetryApi/Logs/LogRecordBuilder.swift

@@ -0,0 +1,44 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Foundation
+
+public protocol LogRecordBuilder {
+
+    /// set the timestamp that the log was observed
+    ///
+    /// - Parameter observed: the Date object
+    /// - Returns: self
+    func setObservedTimestamp (_ observed: Date) -> Self
+
+    /// set the span context associated with the log.
+    ///
+    /// - Parameter context: the associated span context
+    /// - Returns: self
+    func setSpanContext(_ context: SpanContext) -> Self
+
+    /// set the severity of the log.
+    ///
+    /// - Parameter severity: the severity level
+    /// - Returns: self
+    func setSeverity(_ severity: Severity) -> Self
+
+    /// set the body string.
+    ///
+    /// - Parameter body: string value of the log
+    /// - Returns: self
+    func setBody(_ body: String) -> Self
+
+    /// set attributes assoicated with the log.
+    ///
+    /// - Parameter attributes: Array of [String: AttributeValue]
+    /// - Returns:
+    func setAttributes(_ attributes: [String: AttributeValue]) -> Self
+
+    /// emits the log record.
+    func emit()
+}
+
+