Python LoggerFactory.getLogger方法代码示例

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
def setLogLevel(level):
    """setLogLevel(level) changes the log level to level, where level is a string (ERROR, WARN, INFO, DEBUG, and TRACE) """

    logger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME)
    levels = {"ERROR": Level.ERROR, "WARN": Level.WARN, "INFO": Level.INFO, "DEBUG": Level.DEBUG, "TRACE": Level.TRACE}
    l = levels[level.upper()]
    logger.setLevel(l)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
  def __init__(self, args):
    self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
    self.app_id = int(args[Constant.JOB_REF_ID_KEY])
    self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
    self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                 args[Constant.WH_DB_USERNAME_KEY],
                                 args[Constant.WH_DB_PASSWORD_KEY],
                                 args[Constant.WH_DB_DRIVER_KEY])
    self.wh_cursor = self.wh_con.cursor()
    self.aw_con = self.get_connection(args[Constant.AW_DB_URL_KEY],
                                      args[Constant.AW_DB_PORT_KEY],
                                      args[Constant.AW_DB_NAME_KEY],
                                      args[Constant.AW_DB_USERNAME_KEY],
                                      args[Constant.AW_DB_PASSWORD_KEY],
                                      args[Constant.AW_DB_DRIVER_KEY])
    self.aw_cursor = self.aw_con.cursor()
    self.lookback_period = args[Constant.AW_EXEC_ETL_LOOKBACK_KEY]
    self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
    self.metadata_folder = self.app_folder + "/" + str(SchedulerType.APPWORX) + "/" + str(self.app_id)
    self.last_execution_unix_time = None
    self.get_last_execution_unix_time()

    if not os.path.exists(self.metadata_folder):
      try:
        os.makedirs(self.metadata_folder)
      except Exception as e:
        self.logger.error(e)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
  def __init__(self, args):
    self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)

    username = args[Constant.WH_DB_USERNAME_KEY]
    password = args[Constant.WH_DB_PASSWORD_KEY]
    JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
    JDBC_URL = args[Constant.WH_DB_URL_KEY]

    self.db_id = args[Constant.JOB_REF_ID_KEY]
    self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
    self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER)
    self.conn_cursor = self.conn_mysql.cursor()

    if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
      lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
      self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time)

    temp_dir = FileUtil.etl_temp_dir(args, "ORACLE")
    self.input_table_file = os.path.join(temp_dir, args[Constant.ORA_SCHEMA_OUTPUT_KEY])
    self.input_field_file = os.path.join(temp_dir, args[Constant.ORA_FIELD_OUTPUT_KEY])
    self.input_sample_file = os.path.join(temp_dir, args[Constant.ORA_SAMPLE_OUTPUT_KEY])

    self.collect_sample = False
    if Constant.ORA_LOAD_SAMPLE in args:
      self.collect_sample = FileUtil.parse_bool(args[Constant.ORA_LOAD_SAMPLE], False)

    self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}"
                     .format(JDBC_URL, self.db_id, self.wh_etl_exec_id))

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
  def __init__(self, hdfs_uri, kerberos=False, kerberos_principal=None, keytab_file=None):
    """
    :param hdfs_uri: hdfs://hadoop-name-node:port
    :param kerberos: optional, if kerberos authentication is needed
    :param kerberos_principal: optional, [email protected]
    :param keytab_file: optional, absolute path to keytab file
    """
    self.logger = LoggerFactory.getLogger(self.__class__.__name__)

    self.logger.info("keytab_file: " + keytab_file)

    hdfs_conf = Configuration()
    if hdfs_uri.startswith('hdfs://'):
      hdfs_conf.set(Hdfs.FS_DEFAULT_NAME_KEY, hdfs_uri)
    elif hdfs_uri > "":
      self.logger.error("%s is an invalid uri for hdfs namenode ipc bind." % hdfs_uri)

    if kerberos:  #  init kerberos and keytab
      if not kerberos_principal or not keytab_file or kerberos_principal == '' or keytab_file == '':
        print "Kerberos Principal and Keytab File Name/Path are required!"

      hdfs_conf.set("hadoop.security.authentication", "kerberos")
      hdfs_conf.set("dfs.namenode.kerberos.principal.pattern", "*")
      UserGroupInformation.setConfiguration(hdfs_conf)
      UserGroupInformation.loginUserFromKeytab(kerberos_principal, keytab_file)

    self.fs = Hdfs.get(hdfs_conf)

    requests.packages.urllib3.disable_warnings()
    self.logger.info("Initiated SchemaUrlHelper")

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
  def __init__(self, args):
    self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)

    username = args[Constant.WH_DB_USERNAME_KEY]
    password = args[Constant.WH_DB_PASSWORD_KEY]
    JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
    JDBC_URL = args[Constant.WH_DB_URL_KEY]
    self.input_table_file = args[Constant.ORA_SCHEMA_OUTPUT_KEY]
    self.input_field_file = args[Constant.ORA_FIELD_OUTPUT_KEY]
    self.input_sample_file = args[Constant.ORA_SAMPLE_OUTPUT_KEY]

    self.db_id = args[Constant.DB_ID_KEY]
    self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
    self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER)
    self.conn_cursor = self.conn_mysql.cursor()

    if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
      lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
      self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time)

    self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}"
                     .format(JDBC_URL, self.db_id, self.wh_etl_exec_id))

    self.dict_dataset_table = 'dict_dataset'
    self.field_comments_table = 'field_comments'
    self.dict_field_table = 'dict_field_detail'
    self.dict_field_comment_table = 'dict_dataset_field_comment'
    self.dict_dataset_sample_table = 'dict_dataset_sample'

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
	def __init__(self, name='max',
				 labelList=('maxx','maxy','maxval', 'sum'),
				 keyxlabel='maxx', 
				 keyylabel='maxy', 
				 formatString='Maximum value found to be at %f,%f (maxx,maxy) was %f (maxval). Sum was %f (sum)'
				 ):
		self.logger = LoggerFactory.getLogger("SumMaxPositionAndValue:%s" % name)
		TwodDataSetProcessor.__init__(self, name, labelList, keyxlabel, keyylabel, formatString)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor()
   self.app_id = int(args[Constant.JOB_REF_ID_KEY])

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor()
   self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
   self.app_folder = args[Constant.WH_APP_FOLDER_KEY]

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.elasticsearch_index_url = args[Constant.WH_ELASTICSEARCH_URL_KEY]
   self.elasticsearch_port = args[Constant.WH_ELASTICSEARCH_PORT_KEY]
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor(1)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args, scheduler_type):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.app_id = int(args[Constant.APP_ID_KEY])
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor()
   self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
   self.metadata_folder = self.app_folder + "/" + str(scheduler_type) + "/" + str(self.app_id)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   username = args[Constant.HIVE_METASTORE_USERNAME]
   password = args[Constant.HIVE_METASTORE_PASSWORD]
   jdbc_driver = args[Constant.HIVE_METASTORE_JDBC_DRIVER]
   jdbc_url = args[Constant.HIVE_METASTORE_JDBC_URL]
   self.conn_hms = zxJDBC.connect(jdbc_url, username, password, jdbc_driver)
   self.curs = self.conn_hms.cursor()
   dependency_instance_file = args[Constant.HIVE_DEPENDENCY_CSV_FILE_KEY]
   self.instance_writer = FileWriter(dependency_instance_file)

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
	def __init__(self, path, iFileLoader=None, fileLoadTimout=None, printNfsTimes=False, wait_for_exposure_callable=None):
		self.logger = LoggerFactory.getLogger("LazyDataSetProvider:%s" % path)
		self.path = path
		self.iFileLoader = iFileLoader
		self.fileLoadTimout = fileLoadTimout
		self.printNfsTimes = printNfsTimes
		self.wait_for_exposure_callable = wait_for_exposure_callable
		
		self.configureLock = threading.Lock()
		self.dataset = None

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.app_id = int(args[Constant.JOB_REF_ID_KEY])
   self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor()
   self.look_back_days = args[Constant.AW_LINEAGE_ETL_LOOKBACK_KEY]
   self.last_execution_unix_time = None
   self.get_last_execution_unix_time()

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
  def __init__(self):
    self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
    requests.packages.urllib3.disable_warnings()
    self.app_id = int(args[Constant.APP_ID_KEY])
    self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
    self.project_writer = FileWriter(args[Constant.GIT_PROJECT_OUTPUT_KEY])
    self.repo_writer = FileWriter(args[Constant.PRODUCT_REPO_OUTPUT_KEY])
    self.repo_owner_writer = FileWriter(args[Constant.PRODUCT_REPO_OWNER_OUTPUT_KEY])

    self.multiproduct = {}
    self.git_repo = {}
    self.product_repo = []

# 需要导入模块: from org.slf4j import LoggerFactory [as 别名]
# 或者: from org.slf4j.LoggerFactory import getLogger [as 别名]
 def __init__(self, args):
   self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
   self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
                                args[Constant.WH_DB_USERNAME_KEY],
                                args[Constant.WH_DB_PASSWORD_KEY],
                                args[Constant.WH_DB_DRIVER_KEY])
   self.wh_cursor = self.wh_con.cursor()
   self.app_id = int(args[Constant.JOB_REF_ID_KEY])
   self.group_app_id = int(args[Constant.LDAP_GROUP_APP_ID_KEY])
   self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
   self.metadata_folder = self.app_folder + "/" + str(self.app_id)
   self.ceo_user_id = args[Constant.LDAP_CEO_USER_ID_KEY]