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();
}
