Zipkin exporter (#32)

* Zipkin exporter

* fix timestamp

* remove Dispose of http client

Author: SergeyKanzhelev

OpenCensus.sln

@@ -19,6 +19,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{7CB2F02E
 		build\stylecop.json = build\stylecop.json
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCensus.Exporter.Zipkin", "src\OpenCensus.Exporter.Zipkin\OpenCensus.Exporter.Zipkin.csproj", "{7EDAE7FA-B44E-42CA-80FA-7DF2FAA2C5DD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -33,6 +35,10 @@ Global
 		{CC62B3C1-5875-4986-A7F6-C4B26E42B0A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{CC62B3C1-5875-4986-A7F6-C4B26E42B0A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{CC62B3C1-5875-4986-A7F6-C4B26E42B0A1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7EDAE7FA-B44E-42CA-80FA-7DF2FAA2C5DD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7EDAE7FA-B44E-42CA-80FA-7DF2FAA2C5DD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7EDAE7FA-B44E-42CA-80FA-7DF2FAA2C5DD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7EDAE7FA-B44E-42CA-80FA-7DF2FAA2C5DD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/OpenCensus.Exporter.Zipkin/Implementation/TraceExporterHandler.cs

@@ -0,0 +1,347 @@
+// <copyright file="TraceExporterHandler.cs" company="OpenCensus Authors">
+// Copyright 2018, OpenCensus Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of theLicense at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+namespace OpenCensus.Exporter.Zipkin.Implementation
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Net;
+    using System.Net.Http;
+    using System.Net.Security;
+    using System.Net.Sockets;
+    using System.Text;
+    using System.Threading.Tasks;
+    using Newtonsoft.Json;
+    using OpenCensus.Common;
+    using OpenCensus.Trace;
+    using OpenCensus.Trace.Export;
+
+    internal class TraceExporterHandler : IHandler
+    {
+        private const string StatusCode = "census.status_code";
+        private const string StatusDescription = "census.status_description";
+        private const long MillisPerSecond = 1000L;
+        private const long NanosPerMillisecond = 1000 * 1000;
+        private const long NanosPerSecond = NanosPerMillisecond * MillisPerSecond;
+        private readonly ZipkinTraceExporterOptions options;
+        private readonly ZipkinEndpoint localEndpoint;
+        private readonly HttpClient httpClient;
+
+        public TraceExporterHandler(ZipkinTraceExporterOptions options, HttpClient client)
+        {
+            this.options = options;
+            this.localEndpoint = this.GetLocalZipkinEndpoint();
+            this.httpClient = client ?? new HttpClient();
+        }
+
+        public void Export(IList<ISpanData> spanDataList)
+        {
+            List<ZipkinSpan> zipkinSpans = new List<ZipkinSpan>();
+
+            foreach (var data in spanDataList)
+            {
+                var zipkinSpan = this.GenerateSpan(data, this.localEndpoint);
+                zipkinSpans.Add(zipkinSpan);
+            }
+
+            this.SendSpansAsync(zipkinSpans);
+        }
+
+        internal ZipkinSpan GenerateSpan(ISpanData spanData, ZipkinEndpoint localEndpoint)
+        {
+            ISpanContext context = spanData.Context;
+            long startTimestamp = this.ToEpochMicroseconds(spanData.StartTimestamp);
+            long endTimestamp = this.ToEpochMicroseconds(spanData.EndTimestamp);
+
+            ZipkinSpan.Builder spanBuilder =
+                ZipkinSpan.NewBuilder()
+                    .TraceId(this.EncodeTraceId(context.TraceId))
+                    .Id(this.EncodeSpanId(context.SpanId))
+                    .Kind(this.ToSpanKind(spanData))
+                    .Name(spanData.Name)
+                    .Timestamp(this.ToEpochMicroseconds(spanData.StartTimestamp))
+                    .Duration(endTimestamp - startTimestamp)
+                    .LocalEndpoint(localEndpoint);
+
+            if (spanData.ParentSpanId != null && spanData.ParentSpanId.IsValid)
+            {
+                spanBuilder.ParentId(this.EncodeSpanId(spanData.ParentSpanId));
+            }
+
+            foreach (var label in spanData.Attributes.AttributeMap)
+            {
+                spanBuilder.PutTag(label.Key, this.AttributeValueToString(label.Value));
+            }
+
+            Status status = spanData.Status;
+
+            if (status != null)
+            {
+                spanBuilder.PutTag(StatusCode, status.CanonicalCode.ToString());
+
+                if (status.Description != null)
+                {
+                    spanBuilder.PutTag(StatusDescription, status.Description);
+                }
+            }
+
+            foreach (var annotation in spanData.Annotations.Events)
+            {
+                spanBuilder.AddAnnotation(this.ToEpochMicroseconds(annotation.Timestamp), annotation.Event.Description);
+            }
+
+            foreach (var networkEvent in spanData.MessageEvents.Events)
+            {
+                spanBuilder.AddAnnotation(this.ToEpochMicroseconds(networkEvent.Timestamp), networkEvent.Event.Type.ToString());
+            }
+
+            return spanBuilder.Build();
+        }
+
+        private long ToEpochMicroseconds(ITimestamp timestamp)
+        {
+            long nanos = (timestamp.Seconds * NanosPerSecond) + timestamp.Nanos;
+            long micros = nanos / 1000L;
+            return micros;
+        }
+
+        private string AttributeValueToString(IAttributeValue attributeValue)
+        {
+            return attributeValue.Match(
+                (arg) => { return arg; },
+                (arg) => { return arg.ToString(); },
+                (arg) => { return arg.ToString(); },
+                (arg) => { return null; });
+        }
+
+        private string EncodeTraceId(ITraceId traceId)
+        {
+            var id = traceId.ToLowerBase16();
+
+            if (id.Length > 16 && this.options.UseShortTraceIds)
+            {
+                id = id.Substring(id.Length - 16, 16);
+            }
+
+            return id;
+        }
+
+        private string EncodeSpanId(ISpanId spanId)
+        {
+            return spanId.ToLowerBase16();
+        }
+
+        private ZipkinSpanKind ToSpanKind(ISpanData spanData)
+        {
+            foreach (var label in spanData.Attributes.AttributeMap)
+            {
+                if (label.Key.Equals(SpanAttributeConstants.SpanKindKey))
+                {
+                    if (this.IsClientSpanKind(label.Value))
+                    {
+                        return ZipkinSpanKind.CLIENT;
+                    }
+
+                    if (this.IsServerSpanKind(label.Value))
+                    {
+                        return ZipkinSpanKind.SERVER;
+                    }
+                }
+            }
+
+            if (spanData.HasRemoteParent.HasValue && spanData.HasRemoteParent.Value)
+            {
+                return ZipkinSpanKind.SERVER;
+            }
+
+            return ZipkinSpanKind.CLIENT;
+        }
+
+        private bool IsClientSpanKind(IAttributeValue value)
+        {
+            return value.Match(
+                (arg) =>
+                {
+                    return arg.Equals(SpanAttributeConstants.ClientSpanKind);
+                },
+                (arg) =>
+                {
+                    return false;
+                },
+                (arg) =>
+                {
+                    return false;
+                },
+                (arg) =>
+                {
+                    return false;
+                });
+        }
+
+        private bool IsServerSpanKind(IAttributeValue value)
+        {
+            return value.Match(
+                (arg) =>
+                {
+                    return arg.Equals(SpanAttributeConstants.ServerSpanKind);
+                },
+                (arg) =>
+                {
+                    return false;
+                },
+                (arg) =>
+                {
+                    return false;
+                },
+                (arg) =>
+                {
+                    return false;
+                });
+        }
+
+        private async void SendSpansAsync(List<ZipkinSpan> spans)
+        {
+            try
+            {
+                var requestUri = new Uri(this.options.Endpoint);
+                var request = this.GetHttpRequestMessage(HttpMethod.Post, requestUri);
+                request.Content = this.GetRequestContent(spans);
+                await this.DoPost(this.httpClient, request);
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        private async Task DoPost(HttpClient client, HttpRequestMessage request)
+        {
+            try
+            {
+                using (HttpResponseMessage response = await client.SendAsync(request))
+                {
+                    if (response.StatusCode != HttpStatusCode.OK &&
+                        response.StatusCode != HttpStatusCode.Accepted)
+                    {
+                        var statusCode = (int)response.StatusCode;
+                    }
+
+                    return;
+                }
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        private HttpRequestMessage GetHttpRequestMessage(HttpMethod method, Uri requestUri)
+        {
+            var request = new HttpRequestMessage(method, requestUri);
+
+            request.Headers.Add("Accept", "application/json");
+
+            return request;
+        }
+
+        private HttpContent GetRequestContent(IList<ZipkinSpan> toSerialize)
+        {
+            try
+            {
+                string json = JsonConvert.SerializeObject(toSerialize);
+
+                return new StringContent(json, Encoding.UTF8, "application/json");
+            }
+            catch (Exception)
+            {
+            }
+
+            return new StringContent(string.Empty, Encoding.UTF8, "application/json");
+        }
+
+        private ZipkinEndpoint GetLocalZipkinEndpoint()
+        {
+            var result = new ZipkinEndpoint()
+            {
+                ServiceName = this.options.ServiceName
+            };
+
+            string hostName = this.ResolveHostName();
+
+            if (!string.IsNullOrEmpty(hostName))
+            {
+                result.Ipv4 = this.ResolveHostAddress(hostName, AddressFamily.InterNetwork);
+
+                result.Ipv6 = this.ResolveHostAddress(hostName, AddressFamily.InterNetworkV6);
+            }
+
+            return result;
+        }
+
+        private string ResolveHostAddress(string hostName, AddressFamily family)
+        {
+            string result = null;
+
+            try
+            {
+                var results = Dns.GetHostAddresses(hostName);
+
+                if (results != null && results.Length > 0)
+                {
+                    foreach (var addr in results)
+                    {
+                        if (addr.AddressFamily.Equals(family))
+                        {
+                            result = addr.ToString();
+
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore
+            }
+
+            return result;
+        }
+
+        private string ResolveHostName()
+        {
+            string result = null;
+
+            try
+            {
+                result = Dns.GetHostName();
+
+                if (!string.IsNullOrEmpty(result))
+                {
+                    var response = Dns.GetHostEntry(result);
+
+                    if (response != null)
+                    {
+                        return response.HostName;
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore
+            }
+
+            return result;
+        }
+    }
+}

src/OpenCensus.Exporter.Zipkin/Implementation/ZipkinAnnotation.cs

@@ -0,0 +1,29 @@
+// <copyright file="ZipkinAnnotation.cs" company="OpenCensus Authors">
+// Copyright 2018, OpenCensus Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of theLicense at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+namespace OpenCensus.Exporter.Zipkin.Implementation
+{
+    using Newtonsoft.Json;
+
+    internal class ZipkinAnnotation
+    {
+        [JsonProperty("timestamp")]
+        public long Timestamp { get; set; }
+
+        [JsonProperty("value")]
+        public string Value { get; set; }
+    }
+}