ddtrace/contrib/pymongo/parse.py
def parse_msg(msg_bytes):
    """ Return a command from a binary mongo db message or None if we shoudln't
        trace it. The protocol is documented here:
        http://docs.mongodb.com/manual/reference/mongodb-wire-protocol
    """
    # NOTE[matt] this is used for queries in pymongo <= 3.0.0 and for inserts
    # in up to date versions.
    msg_len = len(msg_bytes)
    if msg_len <= 0:
        return None

    header = header_struct.unpack_from(msg_bytes, 0)
    (length, req_id, response_to, op_code) = header

    op = OP_CODES.get(op_code)
    if not op:
        log.debug("unknown op code: %s", op_code)
        return None

    db = None
    coll = None

    offset = header_struct.size
    cmd = None
    if op == "query":
        # NOTE[matt] inserts, updates and queries can all use this opcode

        offset += 4  # skip flags
        ns = _cstring(msg_bytes[offset:])
        offset += len(ns) + 1  # include null terminator

        # note: here coll could be '$cmd' because it can be overridden in the
        # query itself (like {"insert":"songs"})
        db, coll = _split_namespace(ns)

        offset += 8  # skip numberToSkip & numberToReturn
        if msg_len <= MAX_MSG_PARSE_LEN:
            # FIXME[matt] don't try to parse large messages for performance
            # reasons. ideally we'd just peek at the first bytes to get
            # the critical info (op type, collection, query, # of docs)
            # rather than parse the whole thing. i suspect only massive
            # inserts will be affected.
            codec = CodecOptions(SON)
            spec = next(bson.decode_iter(msg_bytes[offset:], codec_options=codec))
            cmd = parse_spec(spec, db)
        else:
            # let's still note that a command happened.
            cmd = Command("command", db, "untraced_message_too_large")

        # If the command didn't contain namespace info, set it here.
        if not cmd.coll:
            cmd.coll = coll

    cmd.metrics[netx.BYTES_OUT] = msg_len
    return cmd
 Return a command from a binary mongo db message or None if we shoudln't
        trace it. The protocol is documented here:
        http://docs.mongodb.com/manual/reference/mongodb-wire-protocol
    
Return a command from a binary mongo db message or None if we shoudln't
trace it.
Return a command from a binary mongo db message or None if we shoudln ' t trace it .
def parse_msg(msg_bytes):
    msg_len = len(msg_bytes)
    if msg_len <= 0:
        return None
    header = header_struct.unpack_from(msg_bytes, 0)
    (length, req_id, response_to, op_code) = header
    op = OP_CODES.get(op_code)
    if not op:
        log.debug("unknown op code: %s", op_code)
        return None
    db = None
    coll = None
    offset = header_struct.size
    cmd = None
    if op == "query":
        offset += 4  
        ns = _cstring(msg_bytes[offset:])
        offset += len(ns) + 1  
        db, coll = _split_namespace(ns)
        offset += 8  
        if msg_len <= MAX_MSG_PARSE_LEN:
            codec = CodecOptions(SON)
            spec = next(bson.decode_iter(msg_bytes[offset:], codec_options=codec))
            cmd = parse_spec(spec, db)
        else:
            cmd = Command("command", db, "untraced_message_too_large")
        if not cmd.coll:
            cmd.coll = coll
    cmd.metrics[netx.BYTES_OUT] = msg_len
    return cmd
def parse_msg ( msg_bytes ) : msg_len = len ( msg_bytes ) if msg_len <= 0 : return None header = header_struct . unpack_from ( msg_bytes , 0 ) ( length , req_id , response_to , op_code ) = header op = OP_CODES . get ( op_code ) if not op : log . debug ( "unknown op code: %s" , op_code ) return None db = None coll = None offset = header_struct . size cmd = None if op == "query" : offset += 4 ns = _cstring ( msg_bytes [ offset : ] ) offset += len ( ns ) + 1 db , coll = _split_namespace ( ns ) offset += 8 if msg_len <= MAX_MSG_PARSE_LEN : codec = CodecOptions ( SON ) spec = next ( bson . decode_iter ( msg_bytes [ offset : ] , codec_options = codec ) ) cmd = parse_spec ( spec , db ) else : cmd = Command ( "command" , db , "untraced_message_too_large" ) if not cmd . coll : cmd . coll = coll cmd . metrics [ netx . BYTES_OUT ] = msg_len return cmd
Return a command from a binary mongo db message or None if we shoudln't
trace it.
Return a command from a binary mongo db message or None if we shoudln ' t trace it .
""" Return a command from a binary mongo db message or None if we shoudln't
        trace it. The protocol is documented here:
        http://docs.mongodb.com/manual/reference/mongodb-wire-protocol
    """ # NOTE[matt] this is used for queries in pymongo <= 3.0.0 and for inserts # in up to date versions. # NOTE[matt] inserts, updates and queries can all use this opcode # skip flags # include null terminator # note: here coll could be '$cmd' because it can be overridden in the # query itself (like {"insert":"songs"}) # skip numberToSkip & numberToReturn # FIXME[matt] don't try to parse large messages for performance # reasons. ideally we'd just peek at the first bytes to get # the critical info (op type, collection, query, # of docs) # rather than parse the whole thing. i suspect only massive # inserts will be affected. # let's still note that a command happened. # If the command didn't contain namespace info, set it here.
msg_bytes