| #!/usr/bin/env python |
| # |
| # Copyright 2007 Google Inc. |
| # |
| # 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 the License 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. |
| # |
| |
| |
| |
| from google.net.proto import ProtocolBuffer |
| import array |
| import dummy_thread as thread |
| |
| __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit |
| unusednames=printElemNumber,debug_strs no-special""" |
| |
| if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'): |
| _extension_runtime = True |
| _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage |
| else: |
| _extension_runtime = False |
| _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage |
| |
| from google.appengine.datastore.entity_pb import * |
| import google.appengine.datastore.entity_pb |
| class AggregateRpcStatsProto(ProtocolBuffer.ProtocolMessage): |
| has_service_call_name_ = 0 |
| service_call_name_ = "" |
| has_total_amount_of_calls_ = 0 |
| total_amount_of_calls_ = 0 |
| has_total_cost_of_calls_microdollars_ = 0 |
| total_cost_of_calls_microdollars_ = 0 |
| |
| def __init__(self, contents=None): |
| self.total_billed_ops_ = [] |
| if contents is not None: self.MergeFromString(contents) |
| |
| def service_call_name(self): return self.service_call_name_ |
| |
| def set_service_call_name(self, x): |
| self.has_service_call_name_ = 1 |
| self.service_call_name_ = x |
| |
| def clear_service_call_name(self): |
| if self.has_service_call_name_: |
| self.has_service_call_name_ = 0 |
| self.service_call_name_ = "" |
| |
| def has_service_call_name(self): return self.has_service_call_name_ |
| |
| def total_amount_of_calls(self): return self.total_amount_of_calls_ |
| |
| def set_total_amount_of_calls(self, x): |
| self.has_total_amount_of_calls_ = 1 |
| self.total_amount_of_calls_ = x |
| |
| def clear_total_amount_of_calls(self): |
| if self.has_total_amount_of_calls_: |
| self.has_total_amount_of_calls_ = 0 |
| self.total_amount_of_calls_ = 0 |
| |
| def has_total_amount_of_calls(self): return self.has_total_amount_of_calls_ |
| |
| def total_cost_of_calls_microdollars(self): return self.total_cost_of_calls_microdollars_ |
| |
| def set_total_cost_of_calls_microdollars(self, x): |
| self.has_total_cost_of_calls_microdollars_ = 1 |
| self.total_cost_of_calls_microdollars_ = x |
| |
| def clear_total_cost_of_calls_microdollars(self): |
| if self.has_total_cost_of_calls_microdollars_: |
| self.has_total_cost_of_calls_microdollars_ = 0 |
| self.total_cost_of_calls_microdollars_ = 0 |
| |
| def has_total_cost_of_calls_microdollars(self): return self.has_total_cost_of_calls_microdollars_ |
| |
| def total_billed_ops_size(self): return len(self.total_billed_ops_) |
| def total_billed_ops_list(self): return self.total_billed_ops_ |
| |
| def total_billed_ops(self, i): |
| return self.total_billed_ops_[i] |
| |
| def mutable_total_billed_ops(self, i): |
| return self.total_billed_ops_[i] |
| |
| def add_total_billed_ops(self): |
| x = BilledOpProto() |
| self.total_billed_ops_.append(x) |
| return x |
| |
| def clear_total_billed_ops(self): |
| self.total_billed_ops_ = [] |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_service_call_name()): self.set_service_call_name(x.service_call_name()) |
| if (x.has_total_amount_of_calls()): self.set_total_amount_of_calls(x.total_amount_of_calls()) |
| if (x.has_total_cost_of_calls_microdollars()): self.set_total_cost_of_calls_microdollars(x.total_cost_of_calls_microdollars()) |
| for i in xrange(x.total_billed_ops_size()): self.add_total_billed_ops().CopyFrom(x.total_billed_ops(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_service_call_name_ != x.has_service_call_name_: return 0 |
| if self.has_service_call_name_ and self.service_call_name_ != x.service_call_name_: return 0 |
| if self.has_total_amount_of_calls_ != x.has_total_amount_of_calls_: return 0 |
| if self.has_total_amount_of_calls_ and self.total_amount_of_calls_ != x.total_amount_of_calls_: return 0 |
| if self.has_total_cost_of_calls_microdollars_ != x.has_total_cost_of_calls_microdollars_: return 0 |
| if self.has_total_cost_of_calls_microdollars_ and self.total_cost_of_calls_microdollars_ != x.total_cost_of_calls_microdollars_: return 0 |
| if len(self.total_billed_ops_) != len(x.total_billed_ops_): return 0 |
| for e1, e2 in zip(self.total_billed_ops_, x.total_billed_ops_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_service_call_name_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: service_call_name not set.') |
| if (not self.has_total_amount_of_calls_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: total_amount_of_calls not set.') |
| for p in self.total_billed_ops_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.service_call_name_)) |
| n += self.lengthVarInt64(self.total_amount_of_calls_) |
| if (self.has_total_cost_of_calls_microdollars_): n += 1 + self.lengthVarInt64(self.total_cost_of_calls_microdollars_) |
| n += 1 * len(self.total_billed_ops_) |
| for i in xrange(len(self.total_billed_ops_)): n += self.lengthString(self.total_billed_ops_[i].ByteSize()) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_service_call_name_): |
| n += 1 |
| n += self.lengthString(len(self.service_call_name_)) |
| if (self.has_total_amount_of_calls_): |
| n += 1 |
| n += self.lengthVarInt64(self.total_amount_of_calls_) |
| if (self.has_total_cost_of_calls_microdollars_): n += 1 + self.lengthVarInt64(self.total_cost_of_calls_microdollars_) |
| n += 1 * len(self.total_billed_ops_) |
| for i in xrange(len(self.total_billed_ops_)): n += self.lengthString(self.total_billed_ops_[i].ByteSizePartial()) |
| return n |
| |
| def Clear(self): |
| self.clear_service_call_name() |
| self.clear_total_amount_of_calls() |
| self.clear_total_cost_of_calls_microdollars() |
| self.clear_total_billed_ops() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.service_call_name_) |
| out.putVarInt32(24) |
| out.putVarInt64(self.total_amount_of_calls_) |
| if (self.has_total_cost_of_calls_microdollars_): |
| out.putVarInt32(32) |
| out.putVarInt64(self.total_cost_of_calls_microdollars_) |
| for i in xrange(len(self.total_billed_ops_)): |
| out.putVarInt32(42) |
| out.putVarInt32(self.total_billed_ops_[i].ByteSize()) |
| self.total_billed_ops_[i].OutputUnchecked(out) |
| |
| def OutputPartial(self, out): |
| if (self.has_service_call_name_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.service_call_name_) |
| if (self.has_total_amount_of_calls_): |
| out.putVarInt32(24) |
| out.putVarInt64(self.total_amount_of_calls_) |
| if (self.has_total_cost_of_calls_microdollars_): |
| out.putVarInt32(32) |
| out.putVarInt64(self.total_cost_of_calls_microdollars_) |
| for i in xrange(len(self.total_billed_ops_)): |
| out.putVarInt32(42) |
| out.putVarInt32(self.total_billed_ops_[i].ByteSizePartial()) |
| self.total_billed_ops_[i].OutputPartial(out) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_service_call_name(d.getPrefixedString()) |
| continue |
| if tt == 24: |
| self.set_total_amount_of_calls(d.getVarInt64()) |
| continue |
| if tt == 32: |
| self.set_total_cost_of_calls_microdollars(d.getVarInt64()) |
| continue |
| if tt == 42: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_total_billed_ops().TryMerge(tmp) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_service_call_name_: res+=prefix+("service_call_name: %s\n" % self.DebugFormatString(self.service_call_name_)) |
| if self.has_total_amount_of_calls_: res+=prefix+("total_amount_of_calls: %s\n" % self.DebugFormatInt64(self.total_amount_of_calls_)) |
| if self.has_total_cost_of_calls_microdollars_: res+=prefix+("total_cost_of_calls_microdollars: %s\n" % self.DebugFormatInt64(self.total_cost_of_calls_microdollars_)) |
| cnt=0 |
| for e in self.total_billed_ops_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("total_billed_ops%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kservice_call_name = 1 |
| ktotal_amount_of_calls = 3 |
| ktotal_cost_of_calls_microdollars = 4 |
| ktotal_billed_ops = 5 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "service_call_name", |
| 3: "total_amount_of_calls", |
| 4: "total_cost_of_calls_microdollars", |
| 5: "total_billed_ops", |
| }, 5) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.STRING, |
| 3: ProtocolBuffer.Encoder.NUMERIC, |
| 4: ProtocolBuffer.Encoder.NUMERIC, |
| 5: ProtocolBuffer.Encoder.STRING, |
| }, 5, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.AggregateRpcStatsProto' |
| class KeyValProto(ProtocolBuffer.ProtocolMessage): |
| has_key_ = 0 |
| key_ = "" |
| has_value_ = 0 |
| value_ = "" |
| |
| def __init__(self, contents=None): |
| if contents is not None: self.MergeFromString(contents) |
| |
| def key(self): return self.key_ |
| |
| def set_key(self, x): |
| self.has_key_ = 1 |
| self.key_ = x |
| |
| def clear_key(self): |
| if self.has_key_: |
| self.has_key_ = 0 |
| self.key_ = "" |
| |
| def has_key(self): return self.has_key_ |
| |
| def value(self): return self.value_ |
| |
| def set_value(self, x): |
| self.has_value_ = 1 |
| self.value_ = x |
| |
| def clear_value(self): |
| if self.has_value_: |
| self.has_value_ = 0 |
| self.value_ = "" |
| |
| def has_value(self): return self.has_value_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_key()): self.set_key(x.key()) |
| if (x.has_value()): self.set_value(x.value()) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_key_ != x.has_key_: return 0 |
| if self.has_key_ and self.key_ != x.key_: return 0 |
| if self.has_value_ != x.has_value_: return 0 |
| if self.has_value_ and self.value_ != x.value_: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_key_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: key not set.') |
| if (not self.has_value_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: value not set.') |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.key_)) |
| n += self.lengthString(len(self.value_)) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_key_): |
| n += 1 |
| n += self.lengthString(len(self.key_)) |
| if (self.has_value_): |
| n += 1 |
| n += self.lengthString(len(self.value_)) |
| return n |
| |
| def Clear(self): |
| self.clear_key() |
| self.clear_value() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.key_) |
| out.putVarInt32(18) |
| out.putPrefixedString(self.value_) |
| |
| def OutputPartial(self, out): |
| if (self.has_key_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.key_) |
| if (self.has_value_): |
| out.putVarInt32(18) |
| out.putPrefixedString(self.value_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_key(d.getPrefixedString()) |
| continue |
| if tt == 18: |
| self.set_value(d.getPrefixedString()) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_)) |
| if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_)) |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kkey = 1 |
| kvalue = 2 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "key", |
| 2: "value", |
| }, 2) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.STRING, |
| 2: ProtocolBuffer.Encoder.STRING, |
| }, 2, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.KeyValProto' |
| class StackFrameProto(ProtocolBuffer.ProtocolMessage): |
| has_class_or_file_name_ = 0 |
| class_or_file_name_ = "" |
| has_line_number_ = 0 |
| line_number_ = 0 |
| has_function_name_ = 0 |
| function_name_ = "" |
| |
| def __init__(self, contents=None): |
| self.variables_ = [] |
| if contents is not None: self.MergeFromString(contents) |
| |
| def class_or_file_name(self): return self.class_or_file_name_ |
| |
| def set_class_or_file_name(self, x): |
| self.has_class_or_file_name_ = 1 |
| self.class_or_file_name_ = x |
| |
| def clear_class_or_file_name(self): |
| if self.has_class_or_file_name_: |
| self.has_class_or_file_name_ = 0 |
| self.class_or_file_name_ = "" |
| |
| def has_class_or_file_name(self): return self.has_class_or_file_name_ |
| |
| def line_number(self): return self.line_number_ |
| |
| def set_line_number(self, x): |
| self.has_line_number_ = 1 |
| self.line_number_ = x |
| |
| def clear_line_number(self): |
| if self.has_line_number_: |
| self.has_line_number_ = 0 |
| self.line_number_ = 0 |
| |
| def has_line_number(self): return self.has_line_number_ |
| |
| def function_name(self): return self.function_name_ |
| |
| def set_function_name(self, x): |
| self.has_function_name_ = 1 |
| self.function_name_ = x |
| |
| def clear_function_name(self): |
| if self.has_function_name_: |
| self.has_function_name_ = 0 |
| self.function_name_ = "" |
| |
| def has_function_name(self): return self.has_function_name_ |
| |
| def variables_size(self): return len(self.variables_) |
| def variables_list(self): return self.variables_ |
| |
| def variables(self, i): |
| return self.variables_[i] |
| |
| def mutable_variables(self, i): |
| return self.variables_[i] |
| |
| def add_variables(self): |
| x = KeyValProto() |
| self.variables_.append(x) |
| return x |
| |
| def clear_variables(self): |
| self.variables_ = [] |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_class_or_file_name()): self.set_class_or_file_name(x.class_or_file_name()) |
| if (x.has_line_number()): self.set_line_number(x.line_number()) |
| if (x.has_function_name()): self.set_function_name(x.function_name()) |
| for i in xrange(x.variables_size()): self.add_variables().CopyFrom(x.variables(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_class_or_file_name_ != x.has_class_or_file_name_: return 0 |
| if self.has_class_or_file_name_ and self.class_or_file_name_ != x.class_or_file_name_: return 0 |
| if self.has_line_number_ != x.has_line_number_: return 0 |
| if self.has_line_number_ and self.line_number_ != x.line_number_: return 0 |
| if self.has_function_name_ != x.has_function_name_: return 0 |
| if self.has_function_name_ and self.function_name_ != x.function_name_: return 0 |
| if len(self.variables_) != len(x.variables_): return 0 |
| for e1, e2 in zip(self.variables_, x.variables_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_class_or_file_name_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: class_or_file_name not set.') |
| if (not self.has_function_name_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: function_name not set.') |
| for p in self.variables_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.class_or_file_name_)) |
| if (self.has_line_number_): n += 1 + self.lengthVarInt64(self.line_number_) |
| n += self.lengthString(len(self.function_name_)) |
| n += 1 * len(self.variables_) |
| for i in xrange(len(self.variables_)): n += self.lengthString(self.variables_[i].ByteSize()) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_class_or_file_name_): |
| n += 1 |
| n += self.lengthString(len(self.class_or_file_name_)) |
| if (self.has_line_number_): n += 1 + self.lengthVarInt64(self.line_number_) |
| if (self.has_function_name_): |
| n += 1 |
| n += self.lengthString(len(self.function_name_)) |
| n += 1 * len(self.variables_) |
| for i in xrange(len(self.variables_)): n += self.lengthString(self.variables_[i].ByteSizePartial()) |
| return n |
| |
| def Clear(self): |
| self.clear_class_or_file_name() |
| self.clear_line_number() |
| self.clear_function_name() |
| self.clear_variables() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.class_or_file_name_) |
| if (self.has_line_number_): |
| out.putVarInt32(16) |
| out.putVarInt32(self.line_number_) |
| out.putVarInt32(26) |
| out.putPrefixedString(self.function_name_) |
| for i in xrange(len(self.variables_)): |
| out.putVarInt32(34) |
| out.putVarInt32(self.variables_[i].ByteSize()) |
| self.variables_[i].OutputUnchecked(out) |
| |
| def OutputPartial(self, out): |
| if (self.has_class_or_file_name_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.class_or_file_name_) |
| if (self.has_line_number_): |
| out.putVarInt32(16) |
| out.putVarInt32(self.line_number_) |
| if (self.has_function_name_): |
| out.putVarInt32(26) |
| out.putPrefixedString(self.function_name_) |
| for i in xrange(len(self.variables_)): |
| out.putVarInt32(34) |
| out.putVarInt32(self.variables_[i].ByteSizePartial()) |
| self.variables_[i].OutputPartial(out) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_class_or_file_name(d.getPrefixedString()) |
| continue |
| if tt == 16: |
| self.set_line_number(d.getVarInt32()) |
| continue |
| if tt == 26: |
| self.set_function_name(d.getPrefixedString()) |
| continue |
| if tt == 34: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_variables().TryMerge(tmp) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_class_or_file_name_: res+=prefix+("class_or_file_name: %s\n" % self.DebugFormatString(self.class_or_file_name_)) |
| if self.has_line_number_: res+=prefix+("line_number: %s\n" % self.DebugFormatInt32(self.line_number_)) |
| if self.has_function_name_: res+=prefix+("function_name: %s\n" % self.DebugFormatString(self.function_name_)) |
| cnt=0 |
| for e in self.variables_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("variables%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kclass_or_file_name = 1 |
| kline_number = 2 |
| kfunction_name = 3 |
| kvariables = 4 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "class_or_file_name", |
| 2: "line_number", |
| 3: "function_name", |
| 4: "variables", |
| }, 4) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.STRING, |
| 2: ProtocolBuffer.Encoder.NUMERIC, |
| 3: ProtocolBuffer.Encoder.STRING, |
| 4: ProtocolBuffer.Encoder.STRING, |
| }, 4, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.StackFrameProto' |
| class BilledOpProto(ProtocolBuffer.ProtocolMessage): |
| |
| |
| DATASTORE_READ = 0 |
| DATASTORE_WRITE = 1 |
| DATASTORE_SMALL = 2 |
| MAIL_RECIPIENT = 3 |
| CHANNEL_OPEN = 4 |
| XMPP_STANZA = 5 |
| CHANNEL_PRESENCE = 6 |
| |
| _BilledOp_NAMES = { |
| 0: "DATASTORE_READ", |
| 1: "DATASTORE_WRITE", |
| 2: "DATASTORE_SMALL", |
| 3: "MAIL_RECIPIENT", |
| 4: "CHANNEL_OPEN", |
| 5: "XMPP_STANZA", |
| 6: "CHANNEL_PRESENCE", |
| } |
| |
| def BilledOp_Name(cls, x): return cls._BilledOp_NAMES.get(x, "") |
| BilledOp_Name = classmethod(BilledOp_Name) |
| |
| has_op_ = 0 |
| op_ = 0 |
| has_num_ops_ = 0 |
| num_ops_ = 0 |
| |
| def __init__(self, contents=None): |
| if contents is not None: self.MergeFromString(contents) |
| |
| def op(self): return self.op_ |
| |
| def set_op(self, x): |
| self.has_op_ = 1 |
| self.op_ = x |
| |
| def clear_op(self): |
| if self.has_op_: |
| self.has_op_ = 0 |
| self.op_ = 0 |
| |
| def has_op(self): return self.has_op_ |
| |
| def num_ops(self): return self.num_ops_ |
| |
| def set_num_ops(self, x): |
| self.has_num_ops_ = 1 |
| self.num_ops_ = x |
| |
| def clear_num_ops(self): |
| if self.has_num_ops_: |
| self.has_num_ops_ = 0 |
| self.num_ops_ = 0 |
| |
| def has_num_ops(self): return self.has_num_ops_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_op()): self.set_op(x.op()) |
| if (x.has_num_ops()): self.set_num_ops(x.num_ops()) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_op_ != x.has_op_: return 0 |
| if self.has_op_ and self.op_ != x.op_: return 0 |
| if self.has_num_ops_ != x.has_num_ops_: return 0 |
| if self.has_num_ops_ and self.num_ops_ != x.num_ops_: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_op_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: op not set.') |
| if (not self.has_num_ops_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: num_ops not set.') |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthVarInt64(self.op_) |
| n += self.lengthVarInt64(self.num_ops_) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_op_): |
| n += 1 |
| n += self.lengthVarInt64(self.op_) |
| if (self.has_num_ops_): |
| n += 1 |
| n += self.lengthVarInt64(self.num_ops_) |
| return n |
| |
| def Clear(self): |
| self.clear_op() |
| self.clear_num_ops() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(8) |
| out.putVarInt32(self.op_) |
| out.putVarInt32(16) |
| out.putVarInt32(self.num_ops_) |
| |
| def OutputPartial(self, out): |
| if (self.has_op_): |
| out.putVarInt32(8) |
| out.putVarInt32(self.op_) |
| if (self.has_num_ops_): |
| out.putVarInt32(16) |
| out.putVarInt32(self.num_ops_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.set_op(d.getVarInt32()) |
| continue |
| if tt == 16: |
| self.set_num_ops(d.getVarInt32()) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_op_: res+=prefix+("op: %s\n" % self.DebugFormatInt32(self.op_)) |
| if self.has_num_ops_: res+=prefix+("num_ops: %s\n" % self.DebugFormatInt32(self.num_ops_)) |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kop = 1 |
| knum_ops = 2 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "op", |
| 2: "num_ops", |
| }, 2) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.NUMERIC, |
| 2: ProtocolBuffer.Encoder.NUMERIC, |
| }, 2, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.BilledOpProto' |
| class DatastoreCallDetailsProto(ProtocolBuffer.ProtocolMessage): |
| has_query_kind_ = 0 |
| query_kind_ = "" |
| has_query_ancestor_ = 0 |
| query_ancestor_ = None |
| has_query_thiscursor_ = 0 |
| query_thiscursor_ = 0 |
| has_query_nextcursor_ = 0 |
| query_nextcursor_ = 0 |
| |
| def __init__(self, contents=None): |
| self.get_successful_fetch_ = [] |
| self.keys_read_ = [] |
| self.keys_written_ = [] |
| self.lazy_init_lock_ = thread.allocate_lock() |
| if contents is not None: self.MergeFromString(contents) |
| |
| def query_kind(self): return self.query_kind_ |
| |
| def set_query_kind(self, x): |
| self.has_query_kind_ = 1 |
| self.query_kind_ = x |
| |
| def clear_query_kind(self): |
| if self.has_query_kind_: |
| self.has_query_kind_ = 0 |
| self.query_kind_ = "" |
| |
| def has_query_kind(self): return self.has_query_kind_ |
| |
| def query_ancestor(self): |
| if self.query_ancestor_ is None: |
| self.lazy_init_lock_.acquire() |
| try: |
| if self.query_ancestor_ is None: self.query_ancestor_ = Reference() |
| finally: |
| self.lazy_init_lock_.release() |
| return self.query_ancestor_ |
| |
| def mutable_query_ancestor(self): self.has_query_ancestor_ = 1; return self.query_ancestor() |
| |
| def clear_query_ancestor(self): |
| |
| if self.has_query_ancestor_: |
| self.has_query_ancestor_ = 0; |
| if self.query_ancestor_ is not None: self.query_ancestor_.Clear() |
| |
| def has_query_ancestor(self): return self.has_query_ancestor_ |
| |
| def query_thiscursor(self): return self.query_thiscursor_ |
| |
| def set_query_thiscursor(self, x): |
| self.has_query_thiscursor_ = 1 |
| self.query_thiscursor_ = x |
| |
| def clear_query_thiscursor(self): |
| if self.has_query_thiscursor_: |
| self.has_query_thiscursor_ = 0 |
| self.query_thiscursor_ = 0 |
| |
| def has_query_thiscursor(self): return self.has_query_thiscursor_ |
| |
| def query_nextcursor(self): return self.query_nextcursor_ |
| |
| def set_query_nextcursor(self, x): |
| self.has_query_nextcursor_ = 1 |
| self.query_nextcursor_ = x |
| |
| def clear_query_nextcursor(self): |
| if self.has_query_nextcursor_: |
| self.has_query_nextcursor_ = 0 |
| self.query_nextcursor_ = 0 |
| |
| def has_query_nextcursor(self): return self.has_query_nextcursor_ |
| |
| def get_successful_fetch_size(self): return len(self.get_successful_fetch_) |
| def get_successful_fetch_list(self): return self.get_successful_fetch_ |
| |
| def get_successful_fetch(self, i): |
| return self.get_successful_fetch_[i] |
| |
| def set_get_successful_fetch(self, i, x): |
| self.get_successful_fetch_[i] = x |
| |
| def add_get_successful_fetch(self, x): |
| self.get_successful_fetch_.append(x) |
| |
| def clear_get_successful_fetch(self): |
| self.get_successful_fetch_ = [] |
| |
| def keys_read_size(self): return len(self.keys_read_) |
| def keys_read_list(self): return self.keys_read_ |
| |
| def keys_read(self, i): |
| return self.keys_read_[i] |
| |
| def mutable_keys_read(self, i): |
| return self.keys_read_[i] |
| |
| def add_keys_read(self): |
| x = Reference() |
| self.keys_read_.append(x) |
| return x |
| |
| def clear_keys_read(self): |
| self.keys_read_ = [] |
| def keys_written_size(self): return len(self.keys_written_) |
| def keys_written_list(self): return self.keys_written_ |
| |
| def keys_written(self, i): |
| return self.keys_written_[i] |
| |
| def mutable_keys_written(self, i): |
| return self.keys_written_[i] |
| |
| def add_keys_written(self): |
| x = Reference() |
| self.keys_written_.append(x) |
| return x |
| |
| def clear_keys_written(self): |
| self.keys_written_ = [] |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_query_kind()): self.set_query_kind(x.query_kind()) |
| if (x.has_query_ancestor()): self.mutable_query_ancestor().MergeFrom(x.query_ancestor()) |
| if (x.has_query_thiscursor()): self.set_query_thiscursor(x.query_thiscursor()) |
| if (x.has_query_nextcursor()): self.set_query_nextcursor(x.query_nextcursor()) |
| for i in xrange(x.get_successful_fetch_size()): self.add_get_successful_fetch(x.get_successful_fetch(i)) |
| for i in xrange(x.keys_read_size()): self.add_keys_read().CopyFrom(x.keys_read(i)) |
| for i in xrange(x.keys_written_size()): self.add_keys_written().CopyFrom(x.keys_written(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_query_kind_ != x.has_query_kind_: return 0 |
| if self.has_query_kind_ and self.query_kind_ != x.query_kind_: return 0 |
| if self.has_query_ancestor_ != x.has_query_ancestor_: return 0 |
| if self.has_query_ancestor_ and self.query_ancestor_ != x.query_ancestor_: return 0 |
| if self.has_query_thiscursor_ != x.has_query_thiscursor_: return 0 |
| if self.has_query_thiscursor_ and self.query_thiscursor_ != x.query_thiscursor_: return 0 |
| if self.has_query_nextcursor_ != x.has_query_nextcursor_: return 0 |
| if self.has_query_nextcursor_ and self.query_nextcursor_ != x.query_nextcursor_: return 0 |
| if len(self.get_successful_fetch_) != len(x.get_successful_fetch_): return 0 |
| for e1, e2 in zip(self.get_successful_fetch_, x.get_successful_fetch_): |
| if e1 != e2: return 0 |
| if len(self.keys_read_) != len(x.keys_read_): return 0 |
| for e1, e2 in zip(self.keys_read_, x.keys_read_): |
| if e1 != e2: return 0 |
| if len(self.keys_written_) != len(x.keys_written_): return 0 |
| for e1, e2 in zip(self.keys_written_, x.keys_written_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (self.has_query_ancestor_ and not self.query_ancestor_.IsInitialized(debug_strs)): initialized = 0 |
| for p in self.keys_read_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| for p in self.keys_written_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| if (self.has_query_kind_): n += 1 + self.lengthString(len(self.query_kind_)) |
| if (self.has_query_ancestor_): n += 1 + self.lengthString(self.query_ancestor_.ByteSize()) |
| if (self.has_query_thiscursor_): n += 9 |
| if (self.has_query_nextcursor_): n += 9 |
| n += 2 * len(self.get_successful_fetch_) |
| n += 1 * len(self.keys_read_) |
| for i in xrange(len(self.keys_read_)): n += self.lengthString(self.keys_read_[i].ByteSize()) |
| n += 1 * len(self.keys_written_) |
| for i in xrange(len(self.keys_written_)): n += self.lengthString(self.keys_written_[i].ByteSize()) |
| return n |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_query_kind_): n += 1 + self.lengthString(len(self.query_kind_)) |
| if (self.has_query_ancestor_): n += 1 + self.lengthString(self.query_ancestor_.ByteSizePartial()) |
| if (self.has_query_thiscursor_): n += 9 |
| if (self.has_query_nextcursor_): n += 9 |
| n += 2 * len(self.get_successful_fetch_) |
| n += 1 * len(self.keys_read_) |
| for i in xrange(len(self.keys_read_)): n += self.lengthString(self.keys_read_[i].ByteSizePartial()) |
| n += 1 * len(self.keys_written_) |
| for i in xrange(len(self.keys_written_)): n += self.lengthString(self.keys_written_[i].ByteSizePartial()) |
| return n |
| |
| def Clear(self): |
| self.clear_query_kind() |
| self.clear_query_ancestor() |
| self.clear_query_thiscursor() |
| self.clear_query_nextcursor() |
| self.clear_get_successful_fetch() |
| self.clear_keys_read() |
| self.clear_keys_written() |
| |
| def OutputUnchecked(self, out): |
| if (self.has_query_kind_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.query_kind_) |
| if (self.has_query_ancestor_): |
| out.putVarInt32(18) |
| out.putVarInt32(self.query_ancestor_.ByteSize()) |
| self.query_ancestor_.OutputUnchecked(out) |
| if (self.has_query_thiscursor_): |
| out.putVarInt32(25) |
| out.put64(self.query_thiscursor_) |
| if (self.has_query_nextcursor_): |
| out.putVarInt32(33) |
| out.put64(self.query_nextcursor_) |
| for i in xrange(len(self.get_successful_fetch_)): |
| out.putVarInt32(40) |
| out.putBoolean(self.get_successful_fetch_[i]) |
| for i in xrange(len(self.keys_read_)): |
| out.putVarInt32(50) |
| out.putVarInt32(self.keys_read_[i].ByteSize()) |
| self.keys_read_[i].OutputUnchecked(out) |
| for i in xrange(len(self.keys_written_)): |
| out.putVarInt32(58) |
| out.putVarInt32(self.keys_written_[i].ByteSize()) |
| self.keys_written_[i].OutputUnchecked(out) |
| |
| def OutputPartial(self, out): |
| if (self.has_query_kind_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.query_kind_) |
| if (self.has_query_ancestor_): |
| out.putVarInt32(18) |
| out.putVarInt32(self.query_ancestor_.ByteSizePartial()) |
| self.query_ancestor_.OutputPartial(out) |
| if (self.has_query_thiscursor_): |
| out.putVarInt32(25) |
| out.put64(self.query_thiscursor_) |
| if (self.has_query_nextcursor_): |
| out.putVarInt32(33) |
| out.put64(self.query_nextcursor_) |
| for i in xrange(len(self.get_successful_fetch_)): |
| out.putVarInt32(40) |
| out.putBoolean(self.get_successful_fetch_[i]) |
| for i in xrange(len(self.keys_read_)): |
| out.putVarInt32(50) |
| out.putVarInt32(self.keys_read_[i].ByteSizePartial()) |
| self.keys_read_[i].OutputPartial(out) |
| for i in xrange(len(self.keys_written_)): |
| out.putVarInt32(58) |
| out.putVarInt32(self.keys_written_[i].ByteSizePartial()) |
| self.keys_written_[i].OutputPartial(out) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_query_kind(d.getPrefixedString()) |
| continue |
| if tt == 18: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.mutable_query_ancestor().TryMerge(tmp) |
| continue |
| if tt == 25: |
| self.set_query_thiscursor(d.get64()) |
| continue |
| if tt == 33: |
| self.set_query_nextcursor(d.get64()) |
| continue |
| if tt == 40: |
| self.add_get_successful_fetch(d.getBoolean()) |
| continue |
| if tt == 50: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_keys_read().TryMerge(tmp) |
| continue |
| if tt == 58: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_keys_written().TryMerge(tmp) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_query_kind_: res+=prefix+("query_kind: %s\n" % self.DebugFormatString(self.query_kind_)) |
| if self.has_query_ancestor_: |
| res+=prefix+"query_ancestor <\n" |
| res+=self.query_ancestor_.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| if self.has_query_thiscursor_: res+=prefix+("query_thiscursor: %s\n" % self.DebugFormatFixed64(self.query_thiscursor_)) |
| if self.has_query_nextcursor_: res+=prefix+("query_nextcursor: %s\n" % self.DebugFormatFixed64(self.query_nextcursor_)) |
| cnt=0 |
| for e in self.get_successful_fetch_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("get_successful_fetch%s: %s\n" % (elm, self.DebugFormatBool(e))) |
| cnt+=1 |
| cnt=0 |
| for e in self.keys_read_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("keys_read%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| cnt=0 |
| for e in self.keys_written_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("keys_written%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kquery_kind = 1 |
| kquery_ancestor = 2 |
| kquery_thiscursor = 3 |
| kquery_nextcursor = 4 |
| kget_successful_fetch = 5 |
| kkeys_read = 6 |
| kkeys_written = 7 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "query_kind", |
| 2: "query_ancestor", |
| 3: "query_thiscursor", |
| 4: "query_nextcursor", |
| 5: "get_successful_fetch", |
| 6: "keys_read", |
| 7: "keys_written", |
| }, 7) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.STRING, |
| 2: ProtocolBuffer.Encoder.STRING, |
| 3: ProtocolBuffer.Encoder.DOUBLE, |
| 4: ProtocolBuffer.Encoder.DOUBLE, |
| 5: ProtocolBuffer.Encoder.NUMERIC, |
| 6: ProtocolBuffer.Encoder.STRING, |
| 7: ProtocolBuffer.Encoder.STRING, |
| }, 7, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.DatastoreCallDetailsProto' |
| class IndividualRpcStatsProto(ProtocolBuffer.ProtocolMessage): |
| has_service_call_name_ = 0 |
| service_call_name_ = "" |
| has_request_data_summary_ = 0 |
| request_data_summary_ = "" |
| has_response_data_summary_ = 0 |
| response_data_summary_ = "" |
| has_api_mcycles_ = 0 |
| api_mcycles_ = 0 |
| has_api_milliseconds_ = 0 |
| api_milliseconds_ = 0 |
| has_start_offset_milliseconds_ = 0 |
| start_offset_milliseconds_ = 0 |
| has_duration_milliseconds_ = 0 |
| duration_milliseconds_ = 0 |
| has_namespace_ = 0 |
| namespace_ = "" |
| has_was_successful_ = 0 |
| was_successful_ = 1 |
| has_datastore_details_ = 0 |
| datastore_details_ = None |
| has_call_cost_microdollars_ = 0 |
| call_cost_microdollars_ = 0 |
| |
| def __init__(self, contents=None): |
| self.call_stack_ = [] |
| self.billed_ops_ = [] |
| self.lazy_init_lock_ = thread.allocate_lock() |
| if contents is not None: self.MergeFromString(contents) |
| |
| def service_call_name(self): return self.service_call_name_ |
| |
| def set_service_call_name(self, x): |
| self.has_service_call_name_ = 1 |
| self.service_call_name_ = x |
| |
| def clear_service_call_name(self): |
| if self.has_service_call_name_: |
| self.has_service_call_name_ = 0 |
| self.service_call_name_ = "" |
| |
| def has_service_call_name(self): return self.has_service_call_name_ |
| |
| def request_data_summary(self): return self.request_data_summary_ |
| |
| def set_request_data_summary(self, x): |
| self.has_request_data_summary_ = 1 |
| self.request_data_summary_ = x |
| |
| def clear_request_data_summary(self): |
| if self.has_request_data_summary_: |
| self.has_request_data_summary_ = 0 |
| self.request_data_summary_ = "" |
| |
| def has_request_data_summary(self): return self.has_request_data_summary_ |
| |
| def response_data_summary(self): return self.response_data_summary_ |
| |
| def set_response_data_summary(self, x): |
| self.has_response_data_summary_ = 1 |
| self.response_data_summary_ = x |
| |
| def clear_response_data_summary(self): |
| if self.has_response_data_summary_: |
| self.has_response_data_summary_ = 0 |
| self.response_data_summary_ = "" |
| |
| def has_response_data_summary(self): return self.has_response_data_summary_ |
| |
| def api_mcycles(self): return self.api_mcycles_ |
| |
| def set_api_mcycles(self, x): |
| self.has_api_mcycles_ = 1 |
| self.api_mcycles_ = x |
| |
| def clear_api_mcycles(self): |
| if self.has_api_mcycles_: |
| self.has_api_mcycles_ = 0 |
| self.api_mcycles_ = 0 |
| |
| def has_api_mcycles(self): return self.has_api_mcycles_ |
| |
| def api_milliseconds(self): return self.api_milliseconds_ |
| |
| def set_api_milliseconds(self, x): |
| self.has_api_milliseconds_ = 1 |
| self.api_milliseconds_ = x |
| |
| def clear_api_milliseconds(self): |
| if self.has_api_milliseconds_: |
| self.has_api_milliseconds_ = 0 |
| self.api_milliseconds_ = 0 |
| |
| def has_api_milliseconds(self): return self.has_api_milliseconds_ |
| |
| def start_offset_milliseconds(self): return self.start_offset_milliseconds_ |
| |
| def set_start_offset_milliseconds(self, x): |
| self.has_start_offset_milliseconds_ = 1 |
| self.start_offset_milliseconds_ = x |
| |
| def clear_start_offset_milliseconds(self): |
| if self.has_start_offset_milliseconds_: |
| self.has_start_offset_milliseconds_ = 0 |
| self.start_offset_milliseconds_ = 0 |
| |
| def has_start_offset_milliseconds(self): return self.has_start_offset_milliseconds_ |
| |
| def duration_milliseconds(self): return self.duration_milliseconds_ |
| |
| def set_duration_milliseconds(self, x): |
| self.has_duration_milliseconds_ = 1 |
| self.duration_milliseconds_ = x |
| |
| def clear_duration_milliseconds(self): |
| if self.has_duration_milliseconds_: |
| self.has_duration_milliseconds_ = 0 |
| self.duration_milliseconds_ = 0 |
| |
| def has_duration_milliseconds(self): return self.has_duration_milliseconds_ |
| |
| def namespace(self): return self.namespace_ |
| |
| def set_namespace(self, x): |
| self.has_namespace_ = 1 |
| self.namespace_ = x |
| |
| def clear_namespace(self): |
| if self.has_namespace_: |
| self.has_namespace_ = 0 |
| self.namespace_ = "" |
| |
| def has_namespace(self): return self.has_namespace_ |
| |
| def was_successful(self): return self.was_successful_ |
| |
| def set_was_successful(self, x): |
| self.has_was_successful_ = 1 |
| self.was_successful_ = x |
| |
| def clear_was_successful(self): |
| if self.has_was_successful_: |
| self.has_was_successful_ = 0 |
| self.was_successful_ = 1 |
| |
| def has_was_successful(self): return self.has_was_successful_ |
| |
| def call_stack_size(self): return len(self.call_stack_) |
| def call_stack_list(self): return self.call_stack_ |
| |
| def call_stack(self, i): |
| return self.call_stack_[i] |
| |
| def mutable_call_stack(self, i): |
| return self.call_stack_[i] |
| |
| def add_call_stack(self): |
| x = StackFrameProto() |
| self.call_stack_.append(x) |
| return x |
| |
| def clear_call_stack(self): |
| self.call_stack_ = [] |
| def datastore_details(self): |
| if self.datastore_details_ is None: |
| self.lazy_init_lock_.acquire() |
| try: |
| if self.datastore_details_ is None: self.datastore_details_ = DatastoreCallDetailsProto() |
| finally: |
| self.lazy_init_lock_.release() |
| return self.datastore_details_ |
| |
| def mutable_datastore_details(self): self.has_datastore_details_ = 1; return self.datastore_details() |
| |
| def clear_datastore_details(self): |
| |
| if self.has_datastore_details_: |
| self.has_datastore_details_ = 0; |
| if self.datastore_details_ is not None: self.datastore_details_.Clear() |
| |
| def has_datastore_details(self): return self.has_datastore_details_ |
| |
| def call_cost_microdollars(self): return self.call_cost_microdollars_ |
| |
| def set_call_cost_microdollars(self, x): |
| self.has_call_cost_microdollars_ = 1 |
| self.call_cost_microdollars_ = x |
| |
| def clear_call_cost_microdollars(self): |
| if self.has_call_cost_microdollars_: |
| self.has_call_cost_microdollars_ = 0 |
| self.call_cost_microdollars_ = 0 |
| |
| def has_call_cost_microdollars(self): return self.has_call_cost_microdollars_ |
| |
| def billed_ops_size(self): return len(self.billed_ops_) |
| def billed_ops_list(self): return self.billed_ops_ |
| |
| def billed_ops(self, i): |
| return self.billed_ops_[i] |
| |
| def mutable_billed_ops(self, i): |
| return self.billed_ops_[i] |
| |
| def add_billed_ops(self): |
| x = BilledOpProto() |
| self.billed_ops_.append(x) |
| return x |
| |
| def clear_billed_ops(self): |
| self.billed_ops_ = [] |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_service_call_name()): self.set_service_call_name(x.service_call_name()) |
| if (x.has_request_data_summary()): self.set_request_data_summary(x.request_data_summary()) |
| if (x.has_response_data_summary()): self.set_response_data_summary(x.response_data_summary()) |
| if (x.has_api_mcycles()): self.set_api_mcycles(x.api_mcycles()) |
| if (x.has_api_milliseconds()): self.set_api_milliseconds(x.api_milliseconds()) |
| if (x.has_start_offset_milliseconds()): self.set_start_offset_milliseconds(x.start_offset_milliseconds()) |
| if (x.has_duration_milliseconds()): self.set_duration_milliseconds(x.duration_milliseconds()) |
| if (x.has_namespace()): self.set_namespace(x.namespace()) |
| if (x.has_was_successful()): self.set_was_successful(x.was_successful()) |
| for i in xrange(x.call_stack_size()): self.add_call_stack().CopyFrom(x.call_stack(i)) |
| if (x.has_datastore_details()): self.mutable_datastore_details().MergeFrom(x.datastore_details()) |
| if (x.has_call_cost_microdollars()): self.set_call_cost_microdollars(x.call_cost_microdollars()) |
| for i in xrange(x.billed_ops_size()): self.add_billed_ops().CopyFrom(x.billed_ops(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_service_call_name_ != x.has_service_call_name_: return 0 |
| if self.has_service_call_name_ and self.service_call_name_ != x.service_call_name_: return 0 |
| if self.has_request_data_summary_ != x.has_request_data_summary_: return 0 |
| if self.has_request_data_summary_ and self.request_data_summary_ != x.request_data_summary_: return 0 |
| if self.has_response_data_summary_ != x.has_response_data_summary_: return 0 |
| if self.has_response_data_summary_ and self.response_data_summary_ != x.response_data_summary_: return 0 |
| if self.has_api_mcycles_ != x.has_api_mcycles_: return 0 |
| if self.has_api_mcycles_ and self.api_mcycles_ != x.api_mcycles_: return 0 |
| if self.has_api_milliseconds_ != x.has_api_milliseconds_: return 0 |
| if self.has_api_milliseconds_ and self.api_milliseconds_ != x.api_milliseconds_: return 0 |
| if self.has_start_offset_milliseconds_ != x.has_start_offset_milliseconds_: return 0 |
| if self.has_start_offset_milliseconds_ and self.start_offset_milliseconds_ != x.start_offset_milliseconds_: return 0 |
| if self.has_duration_milliseconds_ != x.has_duration_milliseconds_: return 0 |
| if self.has_duration_milliseconds_ and self.duration_milliseconds_ != x.duration_milliseconds_: return 0 |
| if self.has_namespace_ != x.has_namespace_: return 0 |
| if self.has_namespace_ and self.namespace_ != x.namespace_: return 0 |
| if self.has_was_successful_ != x.has_was_successful_: return 0 |
| if self.has_was_successful_ and self.was_successful_ != x.was_successful_: return 0 |
| if len(self.call_stack_) != len(x.call_stack_): return 0 |
| for e1, e2 in zip(self.call_stack_, x.call_stack_): |
| if e1 != e2: return 0 |
| if self.has_datastore_details_ != x.has_datastore_details_: return 0 |
| if self.has_datastore_details_ and self.datastore_details_ != x.datastore_details_: return 0 |
| if self.has_call_cost_microdollars_ != x.has_call_cost_microdollars_: return 0 |
| if self.has_call_cost_microdollars_ and self.call_cost_microdollars_ != x.call_cost_microdollars_: return 0 |
| if len(self.billed_ops_) != len(x.billed_ops_): return 0 |
| for e1, e2 in zip(self.billed_ops_, x.billed_ops_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_service_call_name_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: service_call_name not set.') |
| if (not self.has_start_offset_milliseconds_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: start_offset_milliseconds not set.') |
| for p in self.call_stack_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| if (self.has_datastore_details_ and not self.datastore_details_.IsInitialized(debug_strs)): initialized = 0 |
| for p in self.billed_ops_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.service_call_name_)) |
| if (self.has_request_data_summary_): n += 1 + self.lengthString(len(self.request_data_summary_)) |
| if (self.has_response_data_summary_): n += 1 + self.lengthString(len(self.response_data_summary_)) |
| if (self.has_api_mcycles_): n += 1 + self.lengthVarInt64(self.api_mcycles_) |
| if (self.has_api_milliseconds_): n += 1 + self.lengthVarInt64(self.api_milliseconds_) |
| n += self.lengthVarInt64(self.start_offset_milliseconds_) |
| if (self.has_duration_milliseconds_): n += 1 + self.lengthVarInt64(self.duration_milliseconds_) |
| if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_)) |
| if (self.has_was_successful_): n += 2 |
| n += 1 * len(self.call_stack_) |
| for i in xrange(len(self.call_stack_)): n += self.lengthString(self.call_stack_[i].ByteSize()) |
| if (self.has_datastore_details_): n += 1 + self.lengthString(self.datastore_details_.ByteSize()) |
| if (self.has_call_cost_microdollars_): n += 1 + self.lengthVarInt64(self.call_cost_microdollars_) |
| n += 1 * len(self.billed_ops_) |
| for i in xrange(len(self.billed_ops_)): n += self.lengthString(self.billed_ops_[i].ByteSize()) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_service_call_name_): |
| n += 1 |
| n += self.lengthString(len(self.service_call_name_)) |
| if (self.has_request_data_summary_): n += 1 + self.lengthString(len(self.request_data_summary_)) |
| if (self.has_response_data_summary_): n += 1 + self.lengthString(len(self.response_data_summary_)) |
| if (self.has_api_mcycles_): n += 1 + self.lengthVarInt64(self.api_mcycles_) |
| if (self.has_api_milliseconds_): n += 1 + self.lengthVarInt64(self.api_milliseconds_) |
| if (self.has_start_offset_milliseconds_): |
| n += 1 |
| n += self.lengthVarInt64(self.start_offset_milliseconds_) |
| if (self.has_duration_milliseconds_): n += 1 + self.lengthVarInt64(self.duration_milliseconds_) |
| if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_)) |
| if (self.has_was_successful_): n += 2 |
| n += 1 * len(self.call_stack_) |
| for i in xrange(len(self.call_stack_)): n += self.lengthString(self.call_stack_[i].ByteSizePartial()) |
| if (self.has_datastore_details_): n += 1 + self.lengthString(self.datastore_details_.ByteSizePartial()) |
| if (self.has_call_cost_microdollars_): n += 1 + self.lengthVarInt64(self.call_cost_microdollars_) |
| n += 1 * len(self.billed_ops_) |
| for i in xrange(len(self.billed_ops_)): n += self.lengthString(self.billed_ops_[i].ByteSizePartial()) |
| return n |
| |
| def Clear(self): |
| self.clear_service_call_name() |
| self.clear_request_data_summary() |
| self.clear_response_data_summary() |
| self.clear_api_mcycles() |
| self.clear_api_milliseconds() |
| self.clear_start_offset_milliseconds() |
| self.clear_duration_milliseconds() |
| self.clear_namespace() |
| self.clear_was_successful() |
| self.clear_call_stack() |
| self.clear_datastore_details() |
| self.clear_call_cost_microdollars() |
| self.clear_billed_ops() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.service_call_name_) |
| if (self.has_request_data_summary_): |
| out.putVarInt32(26) |
| out.putPrefixedString(self.request_data_summary_) |
| if (self.has_response_data_summary_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.response_data_summary_) |
| if (self.has_api_mcycles_): |
| out.putVarInt32(40) |
| out.putVarInt64(self.api_mcycles_) |
| out.putVarInt32(48) |
| out.putVarInt64(self.start_offset_milliseconds_) |
| if (self.has_duration_milliseconds_): |
| out.putVarInt32(56) |
| out.putVarInt64(self.duration_milliseconds_) |
| if (self.has_namespace_): |
| out.putVarInt32(66) |
| out.putPrefixedString(self.namespace_) |
| if (self.has_was_successful_): |
| out.putVarInt32(72) |
| out.putBoolean(self.was_successful_) |
| for i in xrange(len(self.call_stack_)): |
| out.putVarInt32(82) |
| out.putVarInt32(self.call_stack_[i].ByteSize()) |
| self.call_stack_[i].OutputUnchecked(out) |
| if (self.has_api_milliseconds_): |
| out.putVarInt32(88) |
| out.putVarInt64(self.api_milliseconds_) |
| if (self.has_datastore_details_): |
| out.putVarInt32(98) |
| out.putVarInt32(self.datastore_details_.ByteSize()) |
| self.datastore_details_.OutputUnchecked(out) |
| if (self.has_call_cost_microdollars_): |
| out.putVarInt32(104) |
| out.putVarInt64(self.call_cost_microdollars_) |
| for i in xrange(len(self.billed_ops_)): |
| out.putVarInt32(114) |
| out.putVarInt32(self.billed_ops_[i].ByteSize()) |
| self.billed_ops_[i].OutputUnchecked(out) |
| |
| def OutputPartial(self, out): |
| if (self.has_service_call_name_): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.service_call_name_) |
| if (self.has_request_data_summary_): |
| out.putVarInt32(26) |
| out.putPrefixedString(self.request_data_summary_) |
| if (self.has_response_data_summary_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.response_data_summary_) |
| if (self.has_api_mcycles_): |
| out.putVarInt32(40) |
| out.putVarInt64(self.api_mcycles_) |
| if (self.has_start_offset_milliseconds_): |
| out.putVarInt32(48) |
| out.putVarInt64(self.start_offset_milliseconds_) |
| if (self.has_duration_milliseconds_): |
| out.putVarInt32(56) |
| out.putVarInt64(self.duration_milliseconds_) |
| if (self.has_namespace_): |
| out.putVarInt32(66) |
| out.putPrefixedString(self.namespace_) |
| if (self.has_was_successful_): |
| out.putVarInt32(72) |
| out.putBoolean(self.was_successful_) |
| for i in xrange(len(self.call_stack_)): |
| out.putVarInt32(82) |
| out.putVarInt32(self.call_stack_[i].ByteSizePartial()) |
| self.call_stack_[i].OutputPartial(out) |
| if (self.has_api_milliseconds_): |
| out.putVarInt32(88) |
| out.putVarInt64(self.api_milliseconds_) |
| if (self.has_datastore_details_): |
| out.putVarInt32(98) |
| out.putVarInt32(self.datastore_details_.ByteSizePartial()) |
| self.datastore_details_.OutputPartial(out) |
| if (self.has_call_cost_microdollars_): |
| out.putVarInt32(104) |
| out.putVarInt64(self.call_cost_microdollars_) |
| for i in xrange(len(self.billed_ops_)): |
| out.putVarInt32(114) |
| out.putVarInt32(self.billed_ops_[i].ByteSizePartial()) |
| self.billed_ops_[i].OutputPartial(out) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_service_call_name(d.getPrefixedString()) |
| continue |
| if tt == 26: |
| self.set_request_data_summary(d.getPrefixedString()) |
| continue |
| if tt == 34: |
| self.set_response_data_summary(d.getPrefixedString()) |
| continue |
| if tt == 40: |
| self.set_api_mcycles(d.getVarInt64()) |
| continue |
| if tt == 48: |
| self.set_start_offset_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 56: |
| self.set_duration_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 66: |
| self.set_namespace(d.getPrefixedString()) |
| continue |
| if tt == 72: |
| self.set_was_successful(d.getBoolean()) |
| continue |
| if tt == 82: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_call_stack().TryMerge(tmp) |
| continue |
| if tt == 88: |
| self.set_api_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 98: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.mutable_datastore_details().TryMerge(tmp) |
| continue |
| if tt == 104: |
| self.set_call_cost_microdollars(d.getVarInt64()) |
| continue |
| if tt == 114: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_billed_ops().TryMerge(tmp) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_service_call_name_: res+=prefix+("service_call_name: %s\n" % self.DebugFormatString(self.service_call_name_)) |
| if self.has_request_data_summary_: res+=prefix+("request_data_summary: %s\n" % self.DebugFormatString(self.request_data_summary_)) |
| if self.has_response_data_summary_: res+=prefix+("response_data_summary: %s\n" % self.DebugFormatString(self.response_data_summary_)) |
| if self.has_api_mcycles_: res+=prefix+("api_mcycles: %s\n" % self.DebugFormatInt64(self.api_mcycles_)) |
| if self.has_api_milliseconds_: res+=prefix+("api_milliseconds: %s\n" % self.DebugFormatInt64(self.api_milliseconds_)) |
| if self.has_start_offset_milliseconds_: res+=prefix+("start_offset_milliseconds: %s\n" % self.DebugFormatInt64(self.start_offset_milliseconds_)) |
| if self.has_duration_milliseconds_: res+=prefix+("duration_milliseconds: %s\n" % self.DebugFormatInt64(self.duration_milliseconds_)) |
| if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_)) |
| if self.has_was_successful_: res+=prefix+("was_successful: %s\n" % self.DebugFormatBool(self.was_successful_)) |
| cnt=0 |
| for e in self.call_stack_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("call_stack%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| if self.has_datastore_details_: |
| res+=prefix+"datastore_details <\n" |
| res+=self.datastore_details_.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| if self.has_call_cost_microdollars_: res+=prefix+("call_cost_microdollars: %s\n" % self.DebugFormatInt64(self.call_cost_microdollars_)) |
| cnt=0 |
| for e in self.billed_ops_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("billed_ops%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kservice_call_name = 1 |
| krequest_data_summary = 3 |
| kresponse_data_summary = 4 |
| kapi_mcycles = 5 |
| kapi_milliseconds = 11 |
| kstart_offset_milliseconds = 6 |
| kduration_milliseconds = 7 |
| knamespace = 8 |
| kwas_successful = 9 |
| kcall_stack = 10 |
| kdatastore_details = 12 |
| kcall_cost_microdollars = 13 |
| kbilled_ops = 14 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "service_call_name", |
| 3: "request_data_summary", |
| 4: "response_data_summary", |
| 5: "api_mcycles", |
| 6: "start_offset_milliseconds", |
| 7: "duration_milliseconds", |
| 8: "namespace", |
| 9: "was_successful", |
| 10: "call_stack", |
| 11: "api_milliseconds", |
| 12: "datastore_details", |
| 13: "call_cost_microdollars", |
| 14: "billed_ops", |
| }, 14) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.STRING, |
| 3: ProtocolBuffer.Encoder.STRING, |
| 4: ProtocolBuffer.Encoder.STRING, |
| 5: ProtocolBuffer.Encoder.NUMERIC, |
| 6: ProtocolBuffer.Encoder.NUMERIC, |
| 7: ProtocolBuffer.Encoder.NUMERIC, |
| 8: ProtocolBuffer.Encoder.STRING, |
| 9: ProtocolBuffer.Encoder.NUMERIC, |
| 10: ProtocolBuffer.Encoder.STRING, |
| 11: ProtocolBuffer.Encoder.NUMERIC, |
| 12: ProtocolBuffer.Encoder.STRING, |
| 13: ProtocolBuffer.Encoder.NUMERIC, |
| 14: ProtocolBuffer.Encoder.STRING, |
| }, 14, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.IndividualRpcStatsProto' |
| class RequestStatProto(ProtocolBuffer.ProtocolMessage): |
| has_start_timestamp_milliseconds_ = 0 |
| start_timestamp_milliseconds_ = 0 |
| has_http_method_ = 0 |
| http_method_ = "GET" |
| has_http_path_ = 0 |
| http_path_ = "/" |
| has_http_query_ = 0 |
| http_query_ = "" |
| has_http_status_ = 0 |
| http_status_ = 200 |
| has_duration_milliseconds_ = 0 |
| duration_milliseconds_ = 0 |
| has_api_mcycles_ = 0 |
| api_mcycles_ = 0 |
| has_processor_mcycles_ = 0 |
| processor_mcycles_ = 0 |
| has_overhead_walltime_milliseconds_ = 0 |
| overhead_walltime_milliseconds_ = 0 |
| has_user_email_ = 0 |
| user_email_ = "" |
| has_is_admin_ = 0 |
| is_admin_ = 0 |
| |
| def __init__(self, contents=None): |
| self.rpc_stats_ = [] |
| self.cgi_env_ = [] |
| self.individual_stats_ = [] |
| if contents is not None: self.MergeFromString(contents) |
| |
| def start_timestamp_milliseconds(self): return self.start_timestamp_milliseconds_ |
| |
| def set_start_timestamp_milliseconds(self, x): |
| self.has_start_timestamp_milliseconds_ = 1 |
| self.start_timestamp_milliseconds_ = x |
| |
| def clear_start_timestamp_milliseconds(self): |
| if self.has_start_timestamp_milliseconds_: |
| self.has_start_timestamp_milliseconds_ = 0 |
| self.start_timestamp_milliseconds_ = 0 |
| |
| def has_start_timestamp_milliseconds(self): return self.has_start_timestamp_milliseconds_ |
| |
| def http_method(self): return self.http_method_ |
| |
| def set_http_method(self, x): |
| self.has_http_method_ = 1 |
| self.http_method_ = x |
| |
| def clear_http_method(self): |
| if self.has_http_method_: |
| self.has_http_method_ = 0 |
| self.http_method_ = "GET" |
| |
| def has_http_method(self): return self.has_http_method_ |
| |
| def http_path(self): return self.http_path_ |
| |
| def set_http_path(self, x): |
| self.has_http_path_ = 1 |
| self.http_path_ = x |
| |
| def clear_http_path(self): |
| if self.has_http_path_: |
| self.has_http_path_ = 0 |
| self.http_path_ = "/" |
| |
| def has_http_path(self): return self.has_http_path_ |
| |
| def http_query(self): return self.http_query_ |
| |
| def set_http_query(self, x): |
| self.has_http_query_ = 1 |
| self.http_query_ = x |
| |
| def clear_http_query(self): |
| if self.has_http_query_: |
| self.has_http_query_ = 0 |
| self.http_query_ = "" |
| |
| def has_http_query(self): return self.has_http_query_ |
| |
| def http_status(self): return self.http_status_ |
| |
| def set_http_status(self, x): |
| self.has_http_status_ = 1 |
| self.http_status_ = x |
| |
| def clear_http_status(self): |
| if self.has_http_status_: |
| self.has_http_status_ = 0 |
| self.http_status_ = 200 |
| |
| def has_http_status(self): return self.has_http_status_ |
| |
| def duration_milliseconds(self): return self.duration_milliseconds_ |
| |
| def set_duration_milliseconds(self, x): |
| self.has_duration_milliseconds_ = 1 |
| self.duration_milliseconds_ = x |
| |
| def clear_duration_milliseconds(self): |
| if self.has_duration_milliseconds_: |
| self.has_duration_milliseconds_ = 0 |
| self.duration_milliseconds_ = 0 |
| |
| def has_duration_milliseconds(self): return self.has_duration_milliseconds_ |
| |
| def api_mcycles(self): return self.api_mcycles_ |
| |
| def set_api_mcycles(self, x): |
| self.has_api_mcycles_ = 1 |
| self.api_mcycles_ = x |
| |
| def clear_api_mcycles(self): |
| if self.has_api_mcycles_: |
| self.has_api_mcycles_ = 0 |
| self.api_mcycles_ = 0 |
| |
| def has_api_mcycles(self): return self.has_api_mcycles_ |
| |
| def processor_mcycles(self): return self.processor_mcycles_ |
| |
| def set_processor_mcycles(self, x): |
| self.has_processor_mcycles_ = 1 |
| self.processor_mcycles_ = x |
| |
| def clear_processor_mcycles(self): |
| if self.has_processor_mcycles_: |
| self.has_processor_mcycles_ = 0 |
| self.processor_mcycles_ = 0 |
| |
| def has_processor_mcycles(self): return self.has_processor_mcycles_ |
| |
| def rpc_stats_size(self): return len(self.rpc_stats_) |
| def rpc_stats_list(self): return self.rpc_stats_ |
| |
| def rpc_stats(self, i): |
| return self.rpc_stats_[i] |
| |
| def mutable_rpc_stats(self, i): |
| return self.rpc_stats_[i] |
| |
| def add_rpc_stats(self): |
| x = AggregateRpcStatsProto() |
| self.rpc_stats_.append(x) |
| return x |
| |
| def clear_rpc_stats(self): |
| self.rpc_stats_ = [] |
| def cgi_env_size(self): return len(self.cgi_env_) |
| def cgi_env_list(self): return self.cgi_env_ |
| |
| def cgi_env(self, i): |
| return self.cgi_env_[i] |
| |
| def mutable_cgi_env(self, i): |
| return self.cgi_env_[i] |
| |
| def add_cgi_env(self): |
| x = KeyValProto() |
| self.cgi_env_.append(x) |
| return x |
| |
| def clear_cgi_env(self): |
| self.cgi_env_ = [] |
| def overhead_walltime_milliseconds(self): return self.overhead_walltime_milliseconds_ |
| |
| def set_overhead_walltime_milliseconds(self, x): |
| self.has_overhead_walltime_milliseconds_ = 1 |
| self.overhead_walltime_milliseconds_ = x |
| |
| def clear_overhead_walltime_milliseconds(self): |
| if self.has_overhead_walltime_milliseconds_: |
| self.has_overhead_walltime_milliseconds_ = 0 |
| self.overhead_walltime_milliseconds_ = 0 |
| |
| def has_overhead_walltime_milliseconds(self): return self.has_overhead_walltime_milliseconds_ |
| |
| def user_email(self): return self.user_email_ |
| |
| def set_user_email(self, x): |
| self.has_user_email_ = 1 |
| self.user_email_ = x |
| |
| def clear_user_email(self): |
| if self.has_user_email_: |
| self.has_user_email_ = 0 |
| self.user_email_ = "" |
| |
| def has_user_email(self): return self.has_user_email_ |
| |
| def is_admin(self): return self.is_admin_ |
| |
| def set_is_admin(self, x): |
| self.has_is_admin_ = 1 |
| self.is_admin_ = x |
| |
| def clear_is_admin(self): |
| if self.has_is_admin_: |
| self.has_is_admin_ = 0 |
| self.is_admin_ = 0 |
| |
| def has_is_admin(self): return self.has_is_admin_ |
| |
| def individual_stats_size(self): return len(self.individual_stats_) |
| def individual_stats_list(self): return self.individual_stats_ |
| |
| def individual_stats(self, i): |
| return self.individual_stats_[i] |
| |
| def mutable_individual_stats(self, i): |
| return self.individual_stats_[i] |
| |
| def add_individual_stats(self): |
| x = IndividualRpcStatsProto() |
| self.individual_stats_.append(x) |
| return x |
| |
| def clear_individual_stats(self): |
| self.individual_stats_ = [] |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_start_timestamp_milliseconds()): self.set_start_timestamp_milliseconds(x.start_timestamp_milliseconds()) |
| if (x.has_http_method()): self.set_http_method(x.http_method()) |
| if (x.has_http_path()): self.set_http_path(x.http_path()) |
| if (x.has_http_query()): self.set_http_query(x.http_query()) |
| if (x.has_http_status()): self.set_http_status(x.http_status()) |
| if (x.has_duration_milliseconds()): self.set_duration_milliseconds(x.duration_milliseconds()) |
| if (x.has_api_mcycles()): self.set_api_mcycles(x.api_mcycles()) |
| if (x.has_processor_mcycles()): self.set_processor_mcycles(x.processor_mcycles()) |
| for i in xrange(x.rpc_stats_size()): self.add_rpc_stats().CopyFrom(x.rpc_stats(i)) |
| for i in xrange(x.cgi_env_size()): self.add_cgi_env().CopyFrom(x.cgi_env(i)) |
| if (x.has_overhead_walltime_milliseconds()): self.set_overhead_walltime_milliseconds(x.overhead_walltime_milliseconds()) |
| if (x.has_user_email()): self.set_user_email(x.user_email()) |
| if (x.has_is_admin()): self.set_is_admin(x.is_admin()) |
| for i in xrange(x.individual_stats_size()): self.add_individual_stats().CopyFrom(x.individual_stats(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_start_timestamp_milliseconds_ != x.has_start_timestamp_milliseconds_: return 0 |
| if self.has_start_timestamp_milliseconds_ and self.start_timestamp_milliseconds_ != x.start_timestamp_milliseconds_: return 0 |
| if self.has_http_method_ != x.has_http_method_: return 0 |
| if self.has_http_method_ and self.http_method_ != x.http_method_: return 0 |
| if self.has_http_path_ != x.has_http_path_: return 0 |
| if self.has_http_path_ and self.http_path_ != x.http_path_: return 0 |
| if self.has_http_query_ != x.has_http_query_: return 0 |
| if self.has_http_query_ and self.http_query_ != x.http_query_: return 0 |
| if self.has_http_status_ != x.has_http_status_: return 0 |
| if self.has_http_status_ and self.http_status_ != x.http_status_: return 0 |
| if self.has_duration_milliseconds_ != x.has_duration_milliseconds_: return 0 |
| if self.has_duration_milliseconds_ and self.duration_milliseconds_ != x.duration_milliseconds_: return 0 |
| if self.has_api_mcycles_ != x.has_api_mcycles_: return 0 |
| if self.has_api_mcycles_ and self.api_mcycles_ != x.api_mcycles_: return 0 |
| if self.has_processor_mcycles_ != x.has_processor_mcycles_: return 0 |
| if self.has_processor_mcycles_ and self.processor_mcycles_ != x.processor_mcycles_: return 0 |
| if len(self.rpc_stats_) != len(x.rpc_stats_): return 0 |
| for e1, e2 in zip(self.rpc_stats_, x.rpc_stats_): |
| if e1 != e2: return 0 |
| if len(self.cgi_env_) != len(x.cgi_env_): return 0 |
| for e1, e2 in zip(self.cgi_env_, x.cgi_env_): |
| if e1 != e2: return 0 |
| if self.has_overhead_walltime_milliseconds_ != x.has_overhead_walltime_milliseconds_: return 0 |
| if self.has_overhead_walltime_milliseconds_ and self.overhead_walltime_milliseconds_ != x.overhead_walltime_milliseconds_: return 0 |
| if self.has_user_email_ != x.has_user_email_: return 0 |
| if self.has_user_email_ and self.user_email_ != x.user_email_: return 0 |
| if self.has_is_admin_ != x.has_is_admin_: return 0 |
| if self.has_is_admin_ and self.is_admin_ != x.is_admin_: return 0 |
| if len(self.individual_stats_) != len(x.individual_stats_): return 0 |
| for e1, e2 in zip(self.individual_stats_, x.individual_stats_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_start_timestamp_milliseconds_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: start_timestamp_milliseconds not set.') |
| if (not self.has_duration_milliseconds_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: duration_milliseconds not set.') |
| for p in self.rpc_stats_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| for p in self.cgi_env_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| for p in self.individual_stats_: |
| if not p.IsInitialized(debug_strs): initialized=0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthVarInt64(self.start_timestamp_milliseconds_) |
| if (self.has_http_method_): n += 1 + self.lengthString(len(self.http_method_)) |
| if (self.has_http_path_): n += 1 + self.lengthString(len(self.http_path_)) |
| if (self.has_http_query_): n += 1 + self.lengthString(len(self.http_query_)) |
| if (self.has_http_status_): n += 1 + self.lengthVarInt64(self.http_status_) |
| n += self.lengthVarInt64(self.duration_milliseconds_) |
| if (self.has_api_mcycles_): n += 1 + self.lengthVarInt64(self.api_mcycles_) |
| if (self.has_processor_mcycles_): n += 1 + self.lengthVarInt64(self.processor_mcycles_) |
| n += 1 * len(self.rpc_stats_) |
| for i in xrange(len(self.rpc_stats_)): n += self.lengthString(self.rpc_stats_[i].ByteSize()) |
| n += 2 * len(self.cgi_env_) |
| for i in xrange(len(self.cgi_env_)): n += self.lengthString(self.cgi_env_[i].ByteSize()) |
| if (self.has_overhead_walltime_milliseconds_): n += 2 + self.lengthVarInt64(self.overhead_walltime_milliseconds_) |
| if (self.has_user_email_): n += 2 + self.lengthString(len(self.user_email_)) |
| if (self.has_is_admin_): n += 3 |
| n += 2 * len(self.individual_stats_) |
| for i in xrange(len(self.individual_stats_)): n += self.lengthString(self.individual_stats_[i].ByteSize()) |
| return n + 2 |
| |
| def ByteSizePartial(self): |
| n = 0 |
| if (self.has_start_timestamp_milliseconds_): |
| n += 1 |
| n += self.lengthVarInt64(self.start_timestamp_milliseconds_) |
| if (self.has_http_method_): n += 1 + self.lengthString(len(self.http_method_)) |
| if (self.has_http_path_): n += 1 + self.lengthString(len(self.http_path_)) |
| if (self.has_http_query_): n += 1 + self.lengthString(len(self.http_query_)) |
| if (self.has_http_status_): n += 1 + self.lengthVarInt64(self.http_status_) |
| if (self.has_duration_milliseconds_): |
| n += 1 |
| n += self.lengthVarInt64(self.duration_milliseconds_) |
| if (self.has_api_mcycles_): n += 1 + self.lengthVarInt64(self.api_mcycles_) |
| if (self.has_processor_mcycles_): n += 1 + self.lengthVarInt64(self.processor_mcycles_) |
| n += 1 * len(self.rpc_stats_) |
| for i in xrange(len(self.rpc_stats_)): n += self.lengthString(self.rpc_stats_[i].ByteSizePartial()) |
| n += 2 * len(self.cgi_env_) |
| for i in xrange(len(self.cgi_env_)): n += self.lengthString(self.cgi_env_[i].ByteSizePartial()) |
| if (self.has_overhead_walltime_milliseconds_): n += 2 + self.lengthVarInt64(self.overhead_walltime_milliseconds_) |
| if (self.has_user_email_): n += 2 + self.lengthString(len(self.user_email_)) |
| if (self.has_is_admin_): n += 3 |
| n += 2 * len(self.individual_stats_) |
| for i in xrange(len(self.individual_stats_)): n += self.lengthString(self.individual_stats_[i].ByteSizePartial()) |
| return n |
| |
| def Clear(self): |
| self.clear_start_timestamp_milliseconds() |
| self.clear_http_method() |
| self.clear_http_path() |
| self.clear_http_query() |
| self.clear_http_status() |
| self.clear_duration_milliseconds() |
| self.clear_api_mcycles() |
| self.clear_processor_mcycles() |
| self.clear_rpc_stats() |
| self.clear_cgi_env() |
| self.clear_overhead_walltime_milliseconds() |
| self.clear_user_email() |
| self.clear_is_admin() |
| self.clear_individual_stats() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(8) |
| out.putVarInt64(self.start_timestamp_milliseconds_) |
| if (self.has_http_method_): |
| out.putVarInt32(18) |
| out.putPrefixedString(self.http_method_) |
| if (self.has_http_path_): |
| out.putVarInt32(26) |
| out.putPrefixedString(self.http_path_) |
| if (self.has_http_query_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.http_query_) |
| if (self.has_http_status_): |
| out.putVarInt32(40) |
| out.putVarInt32(self.http_status_) |
| out.putVarInt32(48) |
| out.putVarInt64(self.duration_milliseconds_) |
| if (self.has_api_mcycles_): |
| out.putVarInt32(56) |
| out.putVarInt64(self.api_mcycles_) |
| if (self.has_processor_mcycles_): |
| out.putVarInt32(64) |
| out.putVarInt64(self.processor_mcycles_) |
| for i in xrange(len(self.rpc_stats_)): |
| out.putVarInt32(74) |
| out.putVarInt32(self.rpc_stats_[i].ByteSize()) |
| self.rpc_stats_[i].OutputUnchecked(out) |
| for i in xrange(len(self.cgi_env_)): |
| out.putVarInt32(810) |
| out.putVarInt32(self.cgi_env_[i].ByteSize()) |
| self.cgi_env_[i].OutputUnchecked(out) |
| if (self.has_overhead_walltime_milliseconds_): |
| out.putVarInt32(816) |
| out.putVarInt64(self.overhead_walltime_milliseconds_) |
| if (self.has_user_email_): |
| out.putVarInt32(826) |
| out.putPrefixedString(self.user_email_) |
| if (self.has_is_admin_): |
| out.putVarInt32(832) |
| out.putBoolean(self.is_admin_) |
| for i in xrange(len(self.individual_stats_)): |
| out.putVarInt32(858) |
| out.putVarInt32(self.individual_stats_[i].ByteSize()) |
| self.individual_stats_[i].OutputUnchecked(out) |
| |
| def OutputPartial(self, out): |
| if (self.has_start_timestamp_milliseconds_): |
| out.putVarInt32(8) |
| out.putVarInt64(self.start_timestamp_milliseconds_) |
| if (self.has_http_method_): |
| out.putVarInt32(18) |
| out.putPrefixedString(self.http_method_) |
| if (self.has_http_path_): |
| out.putVarInt32(26) |
| out.putPrefixedString(self.http_path_) |
| if (self.has_http_query_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.http_query_) |
| if (self.has_http_status_): |
| out.putVarInt32(40) |
| out.putVarInt32(self.http_status_) |
| if (self.has_duration_milliseconds_): |
| out.putVarInt32(48) |
| out.putVarInt64(self.duration_milliseconds_) |
| if (self.has_api_mcycles_): |
| out.putVarInt32(56) |
| out.putVarInt64(self.api_mcycles_) |
| if (self.has_processor_mcycles_): |
| out.putVarInt32(64) |
| out.putVarInt64(self.processor_mcycles_) |
| for i in xrange(len(self.rpc_stats_)): |
| out.putVarInt32(74) |
| out.putVarInt32(self.rpc_stats_[i].ByteSizePartial()) |
| self.rpc_stats_[i].OutputPartial(out) |
| for i in xrange(len(self.cgi_env_)): |
| out.putVarInt32(810) |
| out.putVarInt32(self.cgi_env_[i].ByteSizePartial()) |
| self.cgi_env_[i].OutputPartial(out) |
| if (self.has_overhead_walltime_milliseconds_): |
| out.putVarInt32(816) |
| out.putVarInt64(self.overhead_walltime_milliseconds_) |
| if (self.has_user_email_): |
| out.putVarInt32(826) |
| out.putPrefixedString(self.user_email_) |
| if (self.has_is_admin_): |
| out.putVarInt32(832) |
| out.putBoolean(self.is_admin_) |
| for i in xrange(len(self.individual_stats_)): |
| out.putVarInt32(858) |
| out.putVarInt32(self.individual_stats_[i].ByteSizePartial()) |
| self.individual_stats_[i].OutputPartial(out) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.set_start_timestamp_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 18: |
| self.set_http_method(d.getPrefixedString()) |
| continue |
| if tt == 26: |
| self.set_http_path(d.getPrefixedString()) |
| continue |
| if tt == 34: |
| self.set_http_query(d.getPrefixedString()) |
| continue |
| if tt == 40: |
| self.set_http_status(d.getVarInt32()) |
| continue |
| if tt == 48: |
| self.set_duration_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 56: |
| self.set_api_mcycles(d.getVarInt64()) |
| continue |
| if tt == 64: |
| self.set_processor_mcycles(d.getVarInt64()) |
| continue |
| if tt == 74: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_rpc_stats().TryMerge(tmp) |
| continue |
| if tt == 810: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_cgi_env().TryMerge(tmp) |
| continue |
| if tt == 816: |
| self.set_overhead_walltime_milliseconds(d.getVarInt64()) |
| continue |
| if tt == 826: |
| self.set_user_email(d.getPrefixedString()) |
| continue |
| if tt == 832: |
| self.set_is_admin(d.getBoolean()) |
| continue |
| if tt == 858: |
| length = d.getVarInt32() |
| tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
| d.skip(length) |
| self.add_individual_stats().TryMerge(tmp) |
| continue |
| |
| |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_start_timestamp_milliseconds_: res+=prefix+("start_timestamp_milliseconds: %s\n" % self.DebugFormatInt64(self.start_timestamp_milliseconds_)) |
| if self.has_http_method_: res+=prefix+("http_method: %s\n" % self.DebugFormatString(self.http_method_)) |
| if self.has_http_path_: res+=prefix+("http_path: %s\n" % self.DebugFormatString(self.http_path_)) |
| if self.has_http_query_: res+=prefix+("http_query: %s\n" % self.DebugFormatString(self.http_query_)) |
| if self.has_http_status_: res+=prefix+("http_status: %s\n" % self.DebugFormatInt32(self.http_status_)) |
| if self.has_duration_milliseconds_: res+=prefix+("duration_milliseconds: %s\n" % self.DebugFormatInt64(self.duration_milliseconds_)) |
| if self.has_api_mcycles_: res+=prefix+("api_mcycles: %s\n" % self.DebugFormatInt64(self.api_mcycles_)) |
| if self.has_processor_mcycles_: res+=prefix+("processor_mcycles: %s\n" % self.DebugFormatInt64(self.processor_mcycles_)) |
| cnt=0 |
| for e in self.rpc_stats_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("rpc_stats%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| cnt=0 |
| for e in self.cgi_env_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("cgi_env%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| if self.has_overhead_walltime_milliseconds_: res+=prefix+("overhead_walltime_milliseconds: %s\n" % self.DebugFormatInt64(self.overhead_walltime_milliseconds_)) |
| if self.has_user_email_: res+=prefix+("user_email: %s\n" % self.DebugFormatString(self.user_email_)) |
| if self.has_is_admin_: res+=prefix+("is_admin: %s\n" % self.DebugFormatBool(self.is_admin_)) |
| cnt=0 |
| for e in self.individual_stats_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("individual_stats%s <\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| cnt+=1 |
| return res |
| |
| |
| def _BuildTagLookupTable(sparse, maxtag, default=None): |
| return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) |
| |
| kstart_timestamp_milliseconds = 1 |
| khttp_method = 2 |
| khttp_path = 3 |
| khttp_query = 4 |
| khttp_status = 5 |
| kduration_milliseconds = 6 |
| kapi_mcycles = 7 |
| kprocessor_mcycles = 8 |
| krpc_stats = 9 |
| kcgi_env = 101 |
| koverhead_walltime_milliseconds = 102 |
| kuser_email = 103 |
| kis_admin = 104 |
| kindividual_stats = 107 |
| |
| _TEXT = _BuildTagLookupTable({ |
| 0: "ErrorCode", |
| 1: "start_timestamp_milliseconds", |
| 2: "http_method", |
| 3: "http_path", |
| 4: "http_query", |
| 5: "http_status", |
| 6: "duration_milliseconds", |
| 7: "api_mcycles", |
| 8: "processor_mcycles", |
| 9: "rpc_stats", |
| 101: "cgi_env", |
| 102: "overhead_walltime_milliseconds", |
| 103: "user_email", |
| 104: "is_admin", |
| 107: "individual_stats", |
| }, 107) |
| |
| _TYPES = _BuildTagLookupTable({ |
| 0: ProtocolBuffer.Encoder.NUMERIC, |
| 1: ProtocolBuffer.Encoder.NUMERIC, |
| 2: ProtocolBuffer.Encoder.STRING, |
| 3: ProtocolBuffer.Encoder.STRING, |
| 4: ProtocolBuffer.Encoder.STRING, |
| 5: ProtocolBuffer.Encoder.NUMERIC, |
| 6: ProtocolBuffer.Encoder.NUMERIC, |
| 7: ProtocolBuffer.Encoder.NUMERIC, |
| 8: ProtocolBuffer.Encoder.NUMERIC, |
| 9: ProtocolBuffer.Encoder.STRING, |
| 101: ProtocolBuffer.Encoder.STRING, |
| 102: ProtocolBuffer.Encoder.NUMERIC, |
| 103: ProtocolBuffer.Encoder.STRING, |
| 104: ProtocolBuffer.Encoder.NUMERIC, |
| 107: ProtocolBuffer.Encoder.STRING, |
| }, 107, ProtocolBuffer.Encoder.MAX_TYPE) |
| |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| _PROTO_DESCRIPTOR_NAME = 'apphosting.RequestStatProto' |
| if _extension_runtime: |
| pass |
| |
| __all__ = ['AggregateRpcStatsProto','KeyValProto','StackFrameProto','BilledOpProto','DatastoreCallDetailsProto','IndividualRpcStatsProto','RequestStatProto'] |
