incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [02/11] Replacing old jsp status pages with thrift/ajax based pages. Also adding a new page on the status pages for trace viewing.
Date Mon, 02 Dec 2013 13:41:47 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-js/Blur.js
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-js/Blur.js b/distribution/src/main/scripts/interface/gen-js/Blur.js
index 25aed89..bc51fd3 100644
--- a/distribution/src/main/scripts/interface/gen-js/Blur.js
+++ b/distribution/src/main/scripts/interface/gen-js/Blur.js
@@ -4766,6 +4766,521 @@ Blur_startTrace_result.prototype.write = function(output) {
   return;
 };
 
+Blur_traceList_args = function(args) {
+};
+Blur_traceList_args.prototype = {};
+Blur_traceList_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    input.skip(ftype);
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceList_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceList_args');
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceList_result = function(args) {
+  this.success = null;
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.success !== undefined) {
+      this.success = args.success;
+    }
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_traceList_result.prototype = {};
+Blur_traceList_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+      if (ftype == Thrift.Type.LIST) {
+        var _size364 = 0;
+        var _rtmp3368;
+        this.success = [];
+        var _etype367 = 0;
+        _rtmp3368 = input.readListBegin();
+        _etype367 = _rtmp3368.etype;
+        _size364 = _rtmp3368.size;
+        for (var _i369 = 0; _i369 < _size364; ++_i369)
+        {
+          var elem370 = null;
+          elem370 = input.readString().value;
+          this.success.push(elem370);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceList_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceList_result');
+  if (this.success !== null && this.success !== undefined) {
+    output.writeFieldBegin('success', Thrift.Type.LIST, 0);
+    output.writeListBegin(Thrift.Type.STRING, this.success.length);
+    for (var iter371 in this.success)
+    {
+      if (this.success.hasOwnProperty(iter371))
+      {
+        iter371 = this.success[iter371];
+        output.writeString(iter371);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRequestList_args = function(args) {
+  this.traceId = null;
+  if (args) {
+    if (args.traceId !== undefined) {
+      this.traceId = args.traceId;
+    }
+  }
+};
+Blur_traceRequestList_args.prototype = {};
+Blur_traceRequestList_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.traceId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRequestList_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRequestList_args');
+  if (this.traceId !== null && this.traceId !== undefined) {
+    output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
+    output.writeString(this.traceId);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRequestList_result = function(args) {
+  this.success = null;
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.success !== undefined) {
+      this.success = args.success;
+    }
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_traceRequestList_result.prototype = {};
+Blur_traceRequestList_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+      if (ftype == Thrift.Type.LIST) {
+        var _size372 = 0;
+        var _rtmp3376;
+        this.success = [];
+        var _etype375 = 0;
+        _rtmp3376 = input.readListBegin();
+        _etype375 = _rtmp3376.etype;
+        _size372 = _rtmp3376.size;
+        for (var _i377 = 0; _i377 < _size372; ++_i377)
+        {
+          var elem378 = null;
+          elem378 = input.readString().value;
+          this.success.push(elem378);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRequestList_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRequestList_result');
+  if (this.success !== null && this.success !== undefined) {
+    output.writeFieldBegin('success', Thrift.Type.LIST, 0);
+    output.writeListBegin(Thrift.Type.STRING, this.success.length);
+    for (var iter379 in this.success)
+    {
+      if (this.success.hasOwnProperty(iter379))
+      {
+        iter379 = this.success[iter379];
+        output.writeString(iter379);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRequestFetch_args = function(args) {
+  this.traceId = null;
+  this.requestId = null;
+  if (args) {
+    if (args.traceId !== undefined) {
+      this.traceId = args.traceId;
+    }
+    if (args.requestId !== undefined) {
+      this.requestId = args.requestId;
+    }
+  }
+};
+Blur_traceRequestFetch_args.prototype = {};
+Blur_traceRequestFetch_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.traceId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.requestId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRequestFetch_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRequestFetch_args');
+  if (this.traceId !== null && this.traceId !== undefined) {
+    output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
+    output.writeString(this.traceId);
+    output.writeFieldEnd();
+  }
+  if (this.requestId !== null && this.requestId !== undefined) {
+    output.writeFieldBegin('requestId', Thrift.Type.STRING, 2);
+    output.writeString(this.requestId);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRequestFetch_result = function(args) {
+  this.success = null;
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.success !== undefined) {
+      this.success = args.success;
+    }
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_traceRequestFetch_result.prototype = {};
+Blur_traceRequestFetch_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+      if (ftype == Thrift.Type.STRING) {
+        this.success = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRequestFetch_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRequestFetch_result');
+  if (this.success !== null && this.success !== undefined) {
+    output.writeFieldBegin('success', Thrift.Type.STRING, 0);
+    output.writeString(this.success);
+    output.writeFieldEnd();
+  }
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRemove_args = function(args) {
+  this.traceId = null;
+  if (args) {
+    if (args.traceId !== undefined) {
+      this.traceId = args.traceId;
+    }
+  }
+};
+Blur_traceRemove_args.prototype = {};
+Blur_traceRemove_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.traceId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRemove_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRemove_args');
+  if (this.traceId !== null && this.traceId !== undefined) {
+    output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
+    output.writeString(this.traceId);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_traceRemove_result = function(args) {
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_traceRemove_result.prototype = {};
+Blur_traceRemove_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_traceRemove_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_traceRemove_result');
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
 BlurClient = function(input, output) {
     this.input = input;
     this.output = (!output) ? input : output;
@@ -6002,3 +6517,148 @@ BlurClient.prototype.send_startTrace = function(traceId, requestId) {
   this.output.writeMessageEnd();
   return this.output.getTransport().flush();
 };
+BlurClient.prototype.traceList = function() {
+  this.send_traceList();
+  return this.recv_traceList();
+};
+
+BlurClient.prototype.send_traceList = function() {
+  this.output.writeMessageBegin('traceList', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_traceList_args();
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_traceList = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_traceList_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  if (null !== result.success) {
+    return result.success;
+  }
+  throw 'traceList failed: unknown result';
+};
+BlurClient.prototype.traceRequestList = function(traceId) {
+  this.send_traceRequestList(traceId);
+  return this.recv_traceRequestList();
+};
+
+BlurClient.prototype.send_traceRequestList = function(traceId) {
+  this.output.writeMessageBegin('traceRequestList', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_traceRequestList_args();
+  args.traceId = traceId;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_traceRequestList = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_traceRequestList_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  if (null !== result.success) {
+    return result.success;
+  }
+  throw 'traceRequestList failed: unknown result';
+};
+BlurClient.prototype.traceRequestFetch = function(traceId, requestId) {
+  this.send_traceRequestFetch(traceId, requestId);
+  return this.recv_traceRequestFetch();
+};
+
+BlurClient.prototype.send_traceRequestFetch = function(traceId, requestId) {
+  this.output.writeMessageBegin('traceRequestFetch', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_traceRequestFetch_args();
+  args.traceId = traceId;
+  args.requestId = requestId;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_traceRequestFetch = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_traceRequestFetch_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  if (null !== result.success) {
+    return result.success;
+  }
+  throw 'traceRequestFetch failed: unknown result';
+};
+BlurClient.prototype.traceRemove = function(traceId) {
+  this.send_traceRemove(traceId);
+  this.recv_traceRemove();
+};
+
+BlurClient.prototype.send_traceRemove = function(traceId) {
+  this.output.writeMessageBegin('traceRemove', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_traceRemove_args();
+  args.traceId = traceId;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_traceRemove = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_traceRemove_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  return;
+};

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
index 335da5d..fafbd82 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -5466,6 +5466,606 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_traceList_args;
+use base qw(Class::Accessor);
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceList_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceList_args');
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceList_result;
+use base qw(Class::Accessor);
+Blur::Blur_traceList_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceList_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size323 = 0;
+          $self->{success} = [];
+          my $_etype326 = 0;
+          $xfer += $input->readListBegin(\$_etype326, \$_size323);
+          for (my $_i327 = 0; $_i327 < $_size323; ++$_i327)
+          {
+            my $elem328 = undef;
+            $xfer += $input->readString(\$elem328);
+            push(@{$self->{success}},$elem328);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceList_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+    {
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      {
+        foreach my $iter329 (@{$self->{success}}) 
+        {
+          $xfer += $output->writeString($iter329);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRequestList_args;
+use base qw(Class::Accessor);
+Blur::Blur_traceRequestList_args->mk_accessors( qw( traceId ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{traceId} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{traceId}) {
+      $self->{traceId} = $vals->{traceId};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRequestList_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{traceId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRequestList_args');
+  if (defined $self->{traceId}) {
+    $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1);
+    $xfer += $output->writeString($self->{traceId});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRequestList_result;
+use base qw(Class::Accessor);
+Blur::Blur_traceRequestList_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRequestList_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size330 = 0;
+          $self->{success} = [];
+          my $_etype333 = 0;
+          $xfer += $input->readListBegin(\$_etype333, \$_size330);
+          for (my $_i334 = 0; $_i334 < $_size330; ++$_i334)
+          {
+            my $elem335 = undef;
+            $xfer += $input->readString(\$elem335);
+            push(@{$self->{success}},$elem335);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRequestList_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+    {
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      {
+        foreach my $iter336 (@{$self->{success}}) 
+        {
+          $xfer += $output->writeString($iter336);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRequestFetch_args;
+use base qw(Class::Accessor);
+Blur::Blur_traceRequestFetch_args->mk_accessors( qw( traceId requestId ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{traceId} = undef;
+  $self->{requestId} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{traceId}) {
+      $self->{traceId} = $vals->{traceId};
+    }
+    if (defined $vals->{requestId}) {
+      $self->{requestId} = $vals->{requestId};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRequestFetch_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{traceId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{requestId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRequestFetch_args');
+  if (defined $self->{traceId}) {
+    $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1);
+    $xfer += $output->writeString($self->{traceId});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{requestId}) {
+    $xfer += $output->writeFieldBegin('requestId', TType::STRING, 2);
+    $xfer += $output->writeString($self->{requestId});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRequestFetch_result;
+use base qw(Class::Accessor);
+Blur::Blur_traceRequestFetch_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRequestFetch_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^0$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{success});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRequestFetch_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
+    $xfer += $output->writeString($self->{success});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRemove_args;
+use base qw(Class::Accessor);
+Blur::Blur_traceRemove_args->mk_accessors( qw( traceId ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{traceId} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{traceId}) {
+      $self->{traceId} = $vals->{traceId};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRemove_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{traceId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRemove_args');
+  if (defined $self->{traceId}) {
+    $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1);
+    $xfer += $output->writeString($self->{traceId});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_traceRemove_result;
+use base qw(Class::Accessor);
+Blur::Blur_traceRemove_result->mk_accessors( qw( ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_traceRemove_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_traceRemove_result');
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::BlurIf;
 
 use strict;
@@ -5731,6 +6331,34 @@ sub startTrace{
   die 'implement interface';
 }
 
+sub traceList{
+  my $self = shift;
+
+  die 'implement interface';
+}
+
+sub traceRequestList{
+  my $self = shift;
+  my $traceId = shift;
+
+  die 'implement interface';
+}
+
+sub traceRequestFetch{
+  my $self = shift;
+  my $traceId = shift;
+  my $requestId = shift;
+
+  die 'implement interface';
+}
+
+sub traceRemove{
+  my $self = shift;
+  my $traceId = shift;
+
+  die 'implement interface';
+}
+
 package Blur::BlurRest;
 
 use strict;
@@ -6003,6 +6631,34 @@ sub startTrace{
   return $self->{impl}->startTrace($traceId, $requestId);
 }
 
+sub traceList{
+  my ($self, $request) = @_;
+
+  return $self->{impl}->traceList();
+}
+
+sub traceRequestList{
+  my ($self, $request) = @_;
+
+  my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef;
+  return $self->{impl}->traceRequestList($traceId);
+}
+
+sub traceRequestFetch{
+  my ($self, $request) = @_;
+
+  my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef;
+  my $requestId = ($request->{'requestId'}) ? $request->{'requestId'} : undef;
+  return $self->{impl}->traceRequestFetch($traceId, $requestId);
+}
+
+sub traceRemove{
+  my ($self, $request) = @_;
+
+  my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef;
+  return $self->{impl}->traceRemove($traceId);
+}
+
 package Blur::BlurClient;
 
 
@@ -7585,6 +8241,187 @@ sub send_startTrace{
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
+sub traceList{
+  my $self = shift;
+
+    $self->send_traceList();
+  return $self->recv_traceList();
+}
+
+sub send_traceList{
+  my $self = shift;
+
+  $self->{output}->writeMessageBegin('traceList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_traceList_args();
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_traceList{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_traceList_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "traceList failed: unknown result";
+}
+sub traceRequestList{
+  my $self = shift;
+  my $traceId = shift;
+
+    $self->send_traceRequestList($traceId);
+  return $self->recv_traceRequestList();
+}
+
+sub send_traceRequestList{
+  my $self = shift;
+  my $traceId = shift;
+
+  $self->{output}->writeMessageBegin('traceRequestList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_traceRequestList_args();
+  $args->{traceId} = $traceId;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_traceRequestList{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_traceRequestList_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "traceRequestList failed: unknown result";
+}
+sub traceRequestFetch{
+  my $self = shift;
+  my $traceId = shift;
+  my $requestId = shift;
+
+    $self->send_traceRequestFetch($traceId, $requestId);
+  return $self->recv_traceRequestFetch();
+}
+
+sub send_traceRequestFetch{
+  my $self = shift;
+  my $traceId = shift;
+  my $requestId = shift;
+
+  $self->{output}->writeMessageBegin('traceRequestFetch', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_traceRequestFetch_args();
+  $args->{traceId} = $traceId;
+  $args->{requestId} = $requestId;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_traceRequestFetch{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_traceRequestFetch_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "traceRequestFetch failed: unknown result";
+}
+sub traceRemove{
+  my $self = shift;
+  my $traceId = shift;
+
+    $self->send_traceRemove($traceId);
+  $self->recv_traceRemove();
+}
+
+sub send_traceRemove{
+  my $self = shift;
+  my $traceId = shift;
+
+  $self->{output}->writeMessageBegin('traceRemove', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_traceRemove_args();
+  $args->{traceId} = $traceId;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_traceRemove{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_traceRemove_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
 package Blur::BlurProcessor;
 
 use strict;
@@ -8196,4 +9033,72 @@ sub process_startTrace {
     $self->{handler}->startTrace($args->traceId, $args->requestId);
     return;
 }
+sub process_traceList {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_traceList_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_traceList_result();
+    eval {
+      $result->{success} = $self->{handler}->traceList();
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('traceList', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
+sub process_traceRequestList {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_traceRequestList_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_traceRequestList_result();
+    eval {
+      $result->{success} = $self->{handler}->traceRequestList($args->traceId);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('traceRequestList', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
+sub process_traceRequestFetch {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_traceRequestFetch_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_traceRequestFetch_result();
+    eval {
+      $result->{success} = $self->{handler}->traceRequestFetch($args->traceId, $args->requestId);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('traceRequestFetch', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
+sub process_traceRemove {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_traceRemove_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_traceRemove_result();
+    eval {
+      $self->{handler}->traceRemove($args->traceId);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('traceRemove', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-rb/blur.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur.rb b/distribution/src/main/scripts/interface/gen-rb/blur.rb
index 6439b3b..5bd5b2e 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -544,6 +544,69 @@ module Blur
       def send_startTrace(traceId, requestId)
         send_message('startTrace', StartTrace_args, :traceId => traceId, :requestId => requestId)
       end
+      def traceList()
+        send_traceList()
+        return recv_traceList()
+      end
+
+      def send_traceList()
+        send_message('traceList', TraceList_args)
+      end
+
+      def recv_traceList()
+        result = receive_message(TraceList_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceList failed: unknown result')
+      end
+
+      def traceRequestList(traceId)
+        send_traceRequestList(traceId)
+        return recv_traceRequestList()
+      end
+
+      def send_traceRequestList(traceId)
+        send_message('traceRequestList', TraceRequestList_args, :traceId => traceId)
+      end
+
+      def recv_traceRequestList()
+        result = receive_message(TraceRequestList_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceRequestList failed: unknown result')
+      end
+
+      def traceRequestFetch(traceId, requestId)
+        send_traceRequestFetch(traceId, requestId)
+        return recv_traceRequestFetch()
+      end
+
+      def send_traceRequestFetch(traceId, requestId)
+        send_message('traceRequestFetch', TraceRequestFetch_args, :traceId => traceId, :requestId => requestId)
+      end
+
+      def recv_traceRequestFetch()
+        result = receive_message(TraceRequestFetch_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceRequestFetch failed: unknown result')
+      end
+
+      def traceRemove(traceId)
+        send_traceRemove(traceId)
+        recv_traceRemove()
+      end
+
+      def send_traceRemove(traceId)
+        send_message('traceRemove', TraceRemove_args, :traceId => traceId)
+      end
+
+      def recv_traceRemove()
+        result = receive_message(TraceRemove_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
     end
 
     class Processor
@@ -924,6 +987,50 @@ module Blur
         return
       end
 
+      def process_traceList(seqid, iprot, oprot)
+        args = read_args(iprot, TraceList_args)
+        result = TraceList_result.new()
+        begin
+          result.success = @handler.traceList()
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'traceList', seqid)
+      end
+
+      def process_traceRequestList(seqid, iprot, oprot)
+        args = read_args(iprot, TraceRequestList_args)
+        result = TraceRequestList_result.new()
+        begin
+          result.success = @handler.traceRequestList(args.traceId)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'traceRequestList', seqid)
+      end
+
+      def process_traceRequestFetch(seqid, iprot, oprot)
+        args = read_args(iprot, TraceRequestFetch_args)
+        result = TraceRequestFetch_result.new()
+        begin
+          result.success = @handler.traceRequestFetch(args.traceId, args.requestId)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'traceRequestFetch', seqid)
+      end
+
+      def process_traceRemove(seqid, iprot, oprot)
+        args = read_args(iprot, TraceRemove_args)
+        result = TraceRemove_result.new()
+        begin
+          @handler.traceRemove(args.traceId)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'traceRemove', seqid)
+      end
+
     end
 
     # HELPER FUNCTIONS AND STRUCTURES
@@ -2171,6 +2278,145 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class TraceList_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+
+      FIELDS = {
+
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceList_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRequestList_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TRACEID = 1
+
+      FIELDS = {
+        # the trace id.
+        TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRequestList_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRequestFetch_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TRACEID = 1
+      REQUESTID = 2
+
+      FIELDS = {
+        # the trace id.
+        TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'},
+        # the request id.
+        REQUESTID => {:type => ::Thrift::Types::STRING, :name => 'requestId'}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRequestFetch_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRemove_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TRACEID = 1
+
+      FIELDS = {
+        # the trace id.
+        TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class TraceRemove_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      EX = 1
+
+      FIELDS = {
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
   end
 
 end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 2e17c2f..fc56caa 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -134,6 +134,10 @@ limitations under the License.
 <li><a href="#Fn_Blur_configuration">&nbsp;&nbsp;configuration</a></li>
 <li><a href="#Fn_Blur_metrics">&nbsp;&nbsp;metrics</a></li>
 <li><a href="#Fn_Blur_startTrace">&nbsp;&nbsp;startTrace</a></li>
+<li><a href="#Fn_Blur_traceList">&nbsp;&nbsp;traceList</a></li>
+<li><a href="#Fn_Blur_traceRequestList">&nbsp;&nbsp;traceRequestList</a></li>
+<li><a href="#Fn_Blur_traceRequestFetch">&nbsp;&nbsp;traceRequestFetch</a></li>
+<li><a href="#Fn_Blur_traceRemove">&nbsp;&nbsp;traceRemove</a></li>
 </ul></li>
 </ul>
 </li>
@@ -899,6 +903,37 @@ throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
 </td></tr>
 <tr><td>requestId</td><td>the request id, used to connected remote calls together.  Client can pass null.
 </td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceList">Function: Blur.traceList</h4></div><p class="lead">
+<pre><code>list&lt;<code>string</code>&gt;</code> traceList()
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Get a list of all the traces.
+@return the list of trace ids.
+<br/></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRequestList">Function: Blur.traceRequestList</h4></div><p class="lead">
+<pre><code>list&lt;<code>string</code>&gt;</code> traceRequestList(<code>string</code> traceId)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Gets a request list for the given trace.
+@return the list of request ids for the given trace id.
+<br/><br/><h4 id="Parameters_Blur_traceRequestList">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id.
+</td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRequestFetch">Function: Blur.traceRequestFetch</h4></div><p class="lead">
+<pre><code>string</code> traceRequestFetch(<code>string</code> traceId,
+<code>string</code> requestId)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Fetches the given trace.
+@return the json for the given trace request.
+<br/><br/><h4 id="Parameters_Blur_traceRequestFetch">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id.
+</td></tr>
+<tr><td>requestId</td><td>the request id.
+</td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRemove">Function: Blur.traceRemove</h4></div><p class="lead">
+<pre><code>void</code> traceRemove(<code>string</code> traceId)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Remove the trace for the given trace id.
+<br/><br/><h4 id="Parameters_Blur_traceRemove">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id.
+</td></tr>
 </table></p></section>
 </div>
 </div>


Mime
View raw message