public JsonBinaryAnnotation(BinaryAnnotation ba) { key = ba.Key; value = ba.Value; annotationType = ba.Annotation_type.ToString(); endpoint = new JsonEndpoint(ba.Host); switch (ba.Annotation_type) { case AnnotationType.BOOL: value = BitConverter.ToBoolean(ba.Value, 0); break; case AnnotationType.BYTES: value = Convert.ToBase64String(ba.Value); break; case AnnotationType.I16: value = BitConverter.ToInt16(ba.Value, 0); break; case AnnotationType.I32: value = BitConverter.ToInt32(ba.Value, 0); break; case AnnotationType.I64: value = BitConverter.ToInt64(ba.Value, 0); break; case AnnotationType.DOUBLE: value = BitConverter.ToDouble(ba.Value, 0); break; case AnnotationType.STRING: value = Encoding.UTF8.GetString(ba.Value); break; default: throw new Exception(string.Format("Unsupported annotation type: {0}", ba)); } }
public JsonBinaryAnnotation(BinaryAnnotation binaryAnnotation) { if (binaryAnnotation == null) { throw new ArgumentNullException(nameof(binaryAnnotation)); } this.binaryAnnotation = binaryAnnotation; }
public void SubmitBinaryAnnotation(string key, string value) { Span span = SpanAndEndpoint.Span; if (span != null) { BinaryAnnotation ba = new BinaryAnnotation(key, value, SpanAndEndpoint.Endpoint); AddBinaryAnnotation(span, ba); } }
private void AddBinaryAnnotation(string key, object value, Span span, Endpoint endpoint) { var binaryAnnotation = new BinaryAnnotation { Host = endpoint, Key = key, Value = value }; span.Annotations.Add(binaryAnnotation); }
private static void SerializeBinaryAnnotation(StreamWriter writer, BinaryAnnotation binaryAnnotation, IPEndPoint endPoint, string serviceName) { writer.Write(openingBrace); writer.WriteField(key, binaryAnnotation.Key); writer.Write(comma); writer.WriteField(value, Encoding.UTF8.GetString(binaryAnnotation.Value)); writer.Write(comma); writer.WriteAnchor(endpoint); SerializeEndPoint(writer, endPoint, serviceName); writer.Write(closingBrace); }
private void AddBinaryAnnotation(Span span, BinaryAnnotation ba) { lock (span) { if (span.Binary_annotations == null) { span.Binary_annotations = new List <BinaryAnnotation>(); } span.Binary_annotations.Add(ba); } }
private void AddBinaryAnnotation(string key, string value, Span span) { var binaryAnnotation = new BinaryAnnotation() { Host = zipkinEndpoint.GetEndpoint(serviceName), Annotation_type = AnnotationType.STRING, Key = key, Value = Encoding.Default.GetBytes(value) }; span.Binary_annotations.Add(binaryAnnotation); }
public void SubmitAddress(string key, int ipv4, int port, string serviceName) { Span span = SpanAndEndpoint.Span; if (span != null) { serviceName = serviceName != null ? serviceName : "unknown"; BinaryAnnotation ba = new BinaryAnnotation(); ba.Key = key; ba.Value = new byte[] { 1 }; ba.Annotation_type = AnnotationType.BOOL; ba.Host = new Endpoint() { Ipv4 = ipv4, Port = (short)port, Service_name = serviceName }; AddBinaryAnnotation(span, ba); } }
public void Read(TProtocol iprot) { TField field; iprot.ReadStructBegin(); while (true) { field = iprot.ReadFieldBegin(); if (field.Type == TType.Stop) { break; } switch (field.ID) { case 1: if (field.Type == TType.I64) { Trace_id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 3: if (field.Type == TType.String) { Name = iprot.ReadString(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 4: if (field.Type == TType.I64) { Id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 5: if (field.Type == TType.I64) { Parent_id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 6: if (field.Type == TType.List) { { Annotations = new List <Annotation>(); TList _list0 = iprot.ReadListBegin(); for (int _i1 = 0; _i1 < _list0.Count; ++_i1) { Annotation _elem2; _elem2 = new Annotation(); _elem2.Read(iprot); Annotations.Add(_elem2); } iprot.ReadListEnd(); } } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 8: if (field.Type == TType.List) { { Binary_annotations = new List <BinaryAnnotation>(); TList _list3 = iprot.ReadListBegin(); for (int _i4 = 0; _i4 < _list3.Count; ++_i4) { BinaryAnnotation _elem5; _elem5 = new BinaryAnnotation(); _elem5.Read(iprot); Binary_annotations.Add(_elem5); } iprot.ReadListEnd(); } } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 9: if (field.Type == TType.Bool) { Debug = iprot.ReadBool(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; default: TProtocolUtil.Skip(iprot, field.Type); break; } iprot.ReadFieldEnd(); } iprot.ReadStructEnd(); }
public static BinaryAnnotation Read(ThriftProtocol iprot) { iprot.IncrementRecursionDepth(); var annotation = new BinaryAnnotation(); byte[] value = null; try { iprot.ReadStructBegin(); while (true) { var field = iprot.ReadFieldBegin(); if (field.Type == TType.Stop) { break; } switch (field.ID) { case 1: if (field.Type == TType.String) { annotation.Key = iprot.ReadString(); } else { iprot.Skip(field.Type); } break; case 2: if (field.Type == TType.String) { value = iprot.ReadBinary(); } else { iprot.Skip(field.Type); } break; case 3: if (field.Type == TType.I32) { annotation.AnnotationType = (AnnotationType)iprot.ReadI32(); } else { iprot.Skip(field.Type); } break; case 4: if (field.Type == TType.Struct) { // Host = new Endpoint(); // Host.Read(iprot); annotation.Host = EndpointSerializer.Read(iprot); } else { iprot.Skip(field.Type); } break; default: iprot.Skip(field.Type); break; } iprot.ReadFieldEnd(); } iprot.ReadStructEnd(); } finally { iprot.DecrementRecursionDepth(); } // annotation.InitWith(value); if (value != null) { switch (annotation.AnnotationType) { case AnnotationType.BOOL: annotation.ValAsBool = value.Length == 1 && value[0] == 1; break; case AnnotationType.I16: Array.Reverse(value); annotation.ValAsI16 = BitConverter.ToInt16(value, 0); break; case AnnotationType.I32: Array.Reverse(value); annotation.ValAsI32 = BitConverter.ToInt32(value, 0); break; case AnnotationType.I64: Array.Reverse(value); annotation.ValAsI64 = BitConverter.ToInt64(value, 0); break; case AnnotationType.DOUBLE: Array.Reverse(value); annotation.ValAsDouble = BitConverter.ToDouble(value, 0); break; case AnnotationType.BYTES: Array.Reverse(value); annotation.ValAsBArray = value; break; case AnnotationType.STRING: annotation.ValAsString = Encoding.UTF8.GetString(value, 0, value.Length); break; } } return(annotation); }
public static void Write(BinaryAnnotation annotation, ThriftProtocol oprot) { oprot.IncrementRecursionDepth(); try { var struc = new TStruct(/*"BinaryAnnotation"*/); oprot.WriteStructBegin(struc); var field = new TField(); if (annotation.Key != null) { // field.Name = "key"; field.Type = TType.String; field.ID = 1; oprot.WriteFieldBegin(field); oprot.WriteString(annotation.Key); oprot.WriteFieldEnd(); } // if (annotation.Value != null) { // field.Name = "value"; field.Type = TType.String; field.ID = 2; oprot.WriteFieldBegin(field); switch (annotation.AnnotationType) { case AnnotationType.BOOL: oprot.WriteI32(1); oprot.WriteByte((sbyte)(annotation.ValAsBool ? 1 : 0)); break; case AnnotationType.I16: oprot.WriteI32(2); oprot.WriteI16(annotation.ValAsI16); break; case AnnotationType.I32: oprot.WriteI32(4); oprot.WriteI32(annotation.ValAsI32); break; case AnnotationType.I64: oprot.WriteI32(8); oprot.WriteI64(annotation.ValAsI64); break; case AnnotationType.DOUBLE: oprot.WriteI32(8); oprot.WriteDouble(annotation.ValAsDouble); break; case AnnotationType.BYTES: oprot.WriteBinary(annotation.ValAsBArray, 0, annotation.ValAsBArray.Length); break; case AnnotationType.STRING: oprot.WriteString(annotation.ValAsString); break; } // oprot.WriteBinary(annotation.Value); oprot.WriteFieldEnd(); } // if (annotation.AnnotationType != null) { // field.Name = "annotation_type"; field.Type = TType.I32; field.ID = 3; oprot.WriteFieldBegin(field); oprot.WriteI32((int)annotation.AnnotationType); oprot.WriteFieldEnd(); } if (annotation.Host != null) { // field.Name = "host"; field.Type = TType.Struct; field.ID = 4; oprot.WriteFieldBegin(field); EndpointSerializer.Write(annotation.Host, oprot); //annotation.Host.Write(oprot); oprot.WriteFieldEnd(); } oprot.WriteFieldStop(); oprot.WriteStructEnd(); } finally { oprot.DecrementRecursionDepth(); } }
public JsonBinaryAnnotation(BinaryAnnotation binaryAnnotation) { this.binaryAnnotation = binaryAnnotation; this.Endpoint = new JsonEndpoint(binaryAnnotation.Endpoint); }
private void AddBinaryAnnotation(string key, string value, Span span) { var binaryAnnotation = new BinaryAnnotation() { Host = zipkinEndpoint.GetEndpoint(serviceName), Annotation_type = AnnotationType.STRING, Key = key, Value = Encoding.Default.GetBytes(value) }; span.Binary_annotations.Add(binaryAnnotation); }
public void PostSpansTest() { var ep1 = new Endpoint(123, 123, "service1"); var ep2 = new Endpoint(234, 234, "service2"); var ep3 = new Endpoint(345, 345, "service3"); var ep4 = new Endpoint(456, 456, "service4"); var ann1 = new Annotation(100000, Constants.ClientSend, ep1); var ann2 = new Annotation(150000, Constants.ClientRecv, ep1); var spans1 = new List <Span>() { new Span(1, "methodcall", 666, 2, annotations: new List <Annotation>() { ann1, ann2 }) }; var ann3 = new Annotation(101000, Constants.ClientSend, ep2); var ann4 = new Annotation(501000, Constants.ClientRecv, ep2); var spans2 = new List <Span>() { new Span(2, "methodcall", 2, annotations: new List <Annotation>() { ann3, ann4 }) }; var ann5 = new Annotation(99000, Constants.ClientSend, ep2); var ann6 = new Annotation(199000, Constants.ClientRecv, ep2); var spans3 = new List <Span>() { new Span(3, "methodcall", 3, annotations: new List <Annotation>() { ann5, ann6 }) }; // get some server action going on var ann7 = new Annotation(110000, Constants.ServerRecv, ep2); var ann8 = new Annotation(140000, Constants.ServerSend, ep2); var spans4 = new List <Span>() { new Span(2, "methodcall", 666, 2, annotations: new List <Annotation>() { ann1, ann2 }), new Span(2, "methodcall", 666, 2, annotations: new List <Annotation>() { ann7, ann8 }) }; var ann9 = new Annotation(60000, Constants.ClientSend, ep3); var ann10 = new Annotation(65000, "annotation", ep3); var ann11 = new Annotation(100000, Constants.ClientRecv, ep3); var bAnn1 = new BinaryAnnotation("annotation", Encoding.UTF8.GetBytes("ann"), AnnotationType.STRING, ep3); var bAnn2 = new BinaryAnnotation("binary", Encoding.UTF8.GetBytes("ann"), AnnotationType.BYTES, ep3); var spans5 = new List <Span>() { new Span(5, "methodcall", 666, 2, annotations: new List <Annotation>() { ann9, ann10, ann11 }, binaryAnnotations: new List <BinaryAnnotation>() { bAnn1, bAnn2 }) }; var ann13 = new Annotation(100000, Constants.ClientSend, ep4); var ann14 = new Annotation(150000, Constants.ClientRecv, ep4); var spans6 = new List <Span>() { new Span(6, "methodcall", 669, 2, annotations: new List <Annotation>() { ann13, ann14 }) }; var allSpans = spans1.Concat(spans2).Concat(spans3).Concat(spans4).Concat(spans5).Concat(spans6); string postBody = JsonConvert.SerializeObject(allSpans); string contentType = "application/json; charset=utf-8"; Assert.Fail(); }
public void Read (TProtocol iprot) { TField field; iprot.ReadStructBegin(); while (true) { field = iprot.ReadFieldBegin(); if (field.Type == TType.Stop) { break; } switch (field.ID) { case 1: if (field.Type == TType.I64) { Trace_id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 3: if (field.Type == TType.String) { Name = iprot.ReadString(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 4: if (field.Type == TType.I64) { Id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 5: if (field.Type == TType.I64) { Parent_id = iprot.ReadI64(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 6: if (field.Type == TType.List) { { Annotations = new List<Annotation>(); TList _list0 = iprot.ReadListBegin(); for( int _i1 = 0; _i1 < _list0.Count; ++_i1) { Annotation _elem2; _elem2 = new Annotation(); _elem2.Read(iprot); Annotations.Add(_elem2); } iprot.ReadListEnd(); } } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 8: if (field.Type == TType.List) { { Binary_annotations = new List<BinaryAnnotation>(); TList _list3 = iprot.ReadListBegin(); for( int _i4 = 0; _i4 < _list3.Count; ++_i4) { BinaryAnnotation _elem5; _elem5 = new BinaryAnnotation(); _elem5.Read(iprot); Binary_annotations.Add(_elem5); } iprot.ReadListEnd(); } } else { TProtocolUtil.Skip(iprot, field.Type); } break; case 9: if (field.Type == TType.Bool) { Debug = iprot.ReadBool(); } else { TProtocolUtil.Skip(iprot, field.Type); } break; default: TProtocolUtil.Skip(iprot, field.Type); break; } iprot.ReadFieldEnd(); } iprot.ReadStructEnd(); }