def install(): disable_patterns = config.disable_plugins if isinstance(disable_patterns, str): disable_patterns = [re.compile(p.strip()) for p in disable_patterns.split(',') if p.strip()] else: disable_patterns = [re.compile(p.strip()) for p in disable_patterns if p.strip()] for importer, modname, ispkg in pkgutil.iter_modules(skywalking.plugins.__path__): if any(pattern.match(modname) for pattern in disable_patterns): logger.info('plugin %s is disabled and thus won\'t be installed', modname) continue logger.debug('installing plugin %s', modname) plugin = importer.find_module(modname).load_module(modname) supported = pkg_version_check(plugin) if not supported: logger.debug('check version for plugin %s\'s corresponding package failed, thus ' 'won\'t be installed', modname) continue if not hasattr(plugin, 'install') or inspect.ismethod(getattr(plugin, 'install')): logger.warning('no `install` method in plugin %s, thus the plugin won\'t be installed', modname) continue # noinspection PyBroadException try: plugin.install() except Exception: logger.warning('failed to install plugin %s', modname) traceback.print_exc() if logger.isEnabledFor(logging.DEBUG) else None
def start(): global __started if __started: return __started = True flag = False try: from gevent import monkey flag = monkey.is_module_patched("socket") except ModuleNotFoundError: logger.debug( "it was found that no gevent was used, if you don't use, please ignore." ) if flag: import grpc.experimental.gevent as grpc_gevent grpc_gevent.init_gevent() loggings.init() config.finalize() __init() atexit.register(__fini) if (hasattr(os, 'register_at_fork')): os.register_at_fork(before=__fork_before, after_in_parent=__fork_after_in_parent, after_in_child=__fork_after_in_child)
def generator(): while True: segment = queue.get() # type: Segment logger.debug('reporting segment %s', segment) s = SegmentObject( traceId=str(segment.related_traces[0]), traceSegmentId=str(segment.segment_id), service=config.service_name, serviceInstance=config.service_instance, spans=[ SpanObject( spanId=span.sid, parentSpanId=span.pid, startTime=span.start_time, endTime=span.end_time, operationName=span.op, peer=span.peer, spanType=span.kind.name, spanLayer=span.layer.name, componentId=span.component.value, isError=span.error_occurred, logs=[ Log( time=int(log.timestamp * 1000), data=[ KeyStringValuePair(key=item.key, value=item.val) for item in log.items ], ) for log in span.logs ], tags=[ KeyStringValuePair( key=str(tag.key), value=str(tag.val), ) for tag in span.tags ], refs=[ SegmentReference( refType=0 if ref.ref_type == "CrossProcess" else 1, traceId=ref.trace_id, parentTraceSegmentId=ref.segment_id, parentSpanId=ref.span_id, parentService=ref.service, parentServiceInstance=ref.service_instance, parentEndpoint=ref.endpoint, networkAddressUsedAtPeer=ref. client_address, ) for ref in span.refs if ref.trace_id ], ) for span in segment.spans ], ) yield s queue.task_done()
def __init__(self): logger.debug("kafka reporter configs: %s", kafka_configs) self.producer = KafkaProducer(**kafka_configs) self.topic_key_register = "register-" self.topic = config.kafka_topic_management self.send_instance_props()
def generator(): while True: segment = queue.get() # type: Segment logger.debug('reporting segment %s', segment) yield segment queue.task_done()
def _cb(self, state): logger.debug('grpc channel connectivity changed, [%s -> %s]', self.state, state) self.state = state if self.connected(): try: self.service_management.send_instance_props() except grpc.RpcError: self.on_error()
def send_instance_props(self): res = self.session.post(self.url_instance_props, json={ 'service': config.service_name, 'serviceInstance': config.service_instance, 'properties': [{ 'language': 'Python', }] }) logger.debug('heartbeat response: %s', res)
def send_heart_beat(self): logger.debug( 'service heart beats, [%s], [%s]', config.service_name, config.service_instance, ) self.service_stub.keepAlive( InstancePingPkg( service=config.service_name, serviceInstance=config.service_instance, ))
def send_heart_beat(self): logger.debug( 'service heart beats, [%s], [%s]', config.service_name, config.service_instance, ) res = self.session.post(self.url_heart_beat, json={ 'service': config.service_name, 'serviceInstance': config.service_instance, }) logger.debug('heartbeat response: %s', res)
def send_instance_props(self): url = config.collector_address.rstrip( '/') + '/v3/management/reportProperties' res = self.session.post(url, json={ 'service': config.service_name, 'serviceInstance': config.service_instance, 'properties': [{ 'language': 'Python', }] }) logger.debug('heartbeat response: %s', res)
def generator(): while True: try: segment = queue.get(block=block) # type: Segment except Empty: return logger.debug('reporting segment %s', segment) yield segment queue.task_done()
def send_heart_beat(self): logger.debug( 'service heart beats, [%s], [%s]', config.service_name, config.service_instance, ) url = config.collector_address.rstrip('/') + '/v3/management/keepAlive' res = self.session.post(url, json={ 'service': config.service_name, 'serviceInstance': config.service_instance, }) logger.debug('heartbeat response: %s', res)
def generator(): while True: try: timeout = max(0, config.QUEUE_TIMEOUT - int(time() - start)) # type: int segment = queue.get(block=block, timeout=timeout) # type: Segment except Empty: return logger.debug('reporting segment %s', segment) yield segment queue.task_done()
def execute(self, command: ProfileTaskCommand): logger.debug( "ProfileTaskCommandExecutor start execute ProfileTaskCommand [{%s}]", command.serial_number) profile_task = ProfileTask( task_id=command.task_id, first_span_op_name=command.endpoint_name, duration=command.duration, min_duration_threshold=command.min_duration_threshold, thread_dump_period=command.dump_period, max_sampling_count=command.max_sampling_count, start_time=command.start_time, create_time=command.create_time) profile_task_execution_service.add_profile_task(profile_task)
def send_heart_beat(self): logger.debug( 'service heart beats, [%s], [%s]', config.service_name, config.service_instance, ) instance_ping_pkg = InstancePingPkg( service=config.service_name, serviceInstance=config.service_instance, ) key = bytes(instance_ping_pkg.serviceInstance, encoding="utf-8") value = bytes(instance_ping_pkg.SerializeToString()) future = self.producer.send(topic=self.topic, key=key, value=value) res = future.get(timeout=10) logger.debug('heartbeat response: %s', res)
def receive_command(self, commands: Commands): for command in commands.commands: try: base_command = CommandDeserializer.deserialize(command) logger.debug("Received command [{%s} {%s}]", base_command.command, base_command.serial_number) if self.__is_command_executed(base_command): logger.warning("Command[{%s}] is executed, ignored.", base_command.command) continue try: self.__commands.put(base_command) except queue.Full: logger.warning("Command[{%s}, {%s}] cannot add to command list. because the command list is full.", base_command.command, base_command.serial_number) except UnsupportedCommandException as e: logger.warning("Received unsupported command[{%s}].", e.command.command)
def start(): flag = False try: from gevent import monkey flag = monkey.is_module_patched("socket") except ModuleNotFoundError: logger.debug( "it was found that no gevent was used, if you don't use, please ignore." ) if flag: import grpc.experimental.gevent as grpc_gevent grpc_gevent.init_gevent() global __started if __started: raise RuntimeError('the agent can only be started once') loggings.init() config.finalize() __started = True __init() __heartbeat_thread.start() __report_thread.start() atexit.register(__fini)
def query_profile_commands(self): logger.debug("query profile commands") self.profile_query.do_query()
def report(self, generator): for segment in generator: res = self.session.post(self.url_report, json={ 'traceId': str(segment.related_traces[0]), 'traceSegmentId': str(segment.segment_id), 'service': config.service_name, 'serviceInstance': config.service_instance, 'spans': [{ 'spanId': span.sid, 'parentSpanId': span.pid, 'startTime': span.start_time, 'endTime': span.end_time, 'operationName': span.op, 'peer': span.peer, 'spanType': span.kind.name, 'spanLayer': span.layer.name, 'componentId': span.component.value, 'isError': span.error_occurred, 'logs': [{ 'time': int(log.timestamp * 1000), 'data': [{ 'key': item.key, 'value': item.val, } for item in log.items], } for log in span.logs], 'tags': [{ 'key': tag.key, 'value': tag.val, } for tag in span.tags], 'refs': [{ 'refType': 0, 'traceId': ref.trace_id, 'parentTraceSegmentId': ref.segment_id, 'parentSpanId': ref.span_id, 'parentService': ref.service, 'parentServiceInstance': ref.service_instance, 'parentEndpoint': ref.endpoint, 'networkAddressUsedAtPeer': ref.client_address, } for ref in span.refs if ref.trace_id] } for span in segment.spans] }) logger.debug('report traces response: %s', res)