In the end of the day these integration are based on Callback classes. For example, this is the wandb Calback:
class WandbCallback(TrainerCallback): """ A :class:~transformers.TrainerCallbackthat sends the logs toWeight and Biases < >`__.
"""

def __init__(self):
    has_wandb = is_wandb_available()
    assert has_wandb, "WandbCallback requires wandb to be installed. Run `pip install wandb`."
    if has_wandb:
        import wandb

        self._wandb = wandb
    self._initialized = False
    # log outputs
    self._log_model = os.getenv("WANDB_LOG_MODEL", "FALSE").upper() in ENV_VARS_TRUE_VALUES.union({"TRUE"})

def setup(self, args, state, model, **kwargs):
    """
    Setup the optional Weights & Biases (`wandb`) integration.

    One can subclass and override this method to customize the setup if needed. Find more information `here
    < ` ` >`__. You can also override the following environment variables:

    Environment:
        WANDB_LOG_MODEL (:obj:`bool`, `optional`, defaults to :obj:`False`):
            Whether or not to log model as artifact at the end of training. Use along with
            `TrainingArguments.load_best_model_at_end` to upload best model.
        WANDB_WATCH (:obj:`str`, `optional` defaults to :obj:`"gradients"`):
            Can be :obj:`"gradients"`, :obj:`"all"` or :obj:`"false"`. Set to :obj:`"false"` to disable gradient
            logging or :obj:`"all"` to log gradients and parameters.
        WANDB_PROJECT (:obj:`str`, `optional`, defaults to :obj:`"huggingface"`):
            Set this to a custom string to store results in a different project.
        WANDB_DISABLED (:obj:`bool`, `optional`, defaults to :obj:`False`):
            Whether or not to disable wandb entirely. Set `WANDB_DISABLED=true` to disable.
    """
    if self._wandb is None:
        return
    self._initialized = True
    if state.is_world_process_zero:
        logger.info(
            'Automatic Weights & Biases logging enabled, to disable set os.environ["WANDB_DISABLED"] = "true"'
        )
        combined_dict = {**args.to_sanitized_dict()}

        if hasattr(model, "config") and model.config is not None:
            model_config = model.config.to_dict()
            combined_dict = {**model_config, **combined_dict}
        trial_name = state.trial_name
        init_args = {}
        if trial_name is not None:
            run_name = trial_name
            init_args["group"] = args.run_name
        else:
            run_name = args.run_name

        if self._wandb.run is None:
            self._wandb.init(
                project=os.getenv("WANDB_PROJECT", "huggingface"),
                name=run_name,
                **init_args,
            )
        # add config parameters (run may have been created manually)
        self._wandb.config.update(combined_dict, allow_val_change=True)

        # define default x-axis (for latest wandb versions)
        if getattr(self._wandb, "define_metric", None):
            self._wandb.define_metric("train/global_step")
            self._wandb.define_metric("*", step_metric="train/global_step", step_sync=True)

        # keep track of model topology and gradients, unsupported on TPU
        if not is_torch_tpu_available() and os.getenv("WANDB_WATCH") != "false":
            self._wandb.watch(
                model, log=os.getenv("WANDB_WATCH", "gradients"), log_freq=max(100, args.logging_steps)
            )

def on_train_begin(self, args, state, control, model=None, **kwargs):
    if self._wandb is None:
        return
    hp_search = state.is_hyper_param_search
    if hp_search:
        self._wandb.finish()
        self._initialized = False
    if not self._initialized:
        self.setup(args, state, model, **kwargs)

def on_train_end(self, args, state, control, model=None, tokenizer=None, **kwargs):
    if self._wandb is None:
        return
    if self._log_model and self._initialized and state.is_world_process_zero:
        from .trainer import Trainer

        fake_trainer = Trainer(args=args, model=model, tokenizer=tokenizer)
        with tempfile.TemporaryDirectory() as temp_dir:
            fake_trainer.save_model(temp_dir)
            metadata = (
                {
                    k: v
                    for k, v in dict(self._wandb.summary).items()
                    if isinstance(v, numbers.Number) and not k.startswith("_")
                }
                if not args.load_best_model_at_end
                else {
                    f"eval/{args.metric_for_best_model}": state.best_metric,
                    "train/total_floss": state.total_flos,
                }
            )
            artifact = self._wandb.Artifact(name=f"model-{self._wandb.run.id}", type="model", metadata=metadata)
            for f in Path(temp_dir).glob("*"):
                if f.is_file():
                    with artifact.new_file(f.name, mode="wb") as fa:
                        fa.write(f.read_bytes())
            self._wandb.run.log_artifact(artifact)

def on_log(self, args, state, control, model=None, logs=None, **kwargs):
    if self._wandb is None:
        return
    if not self._initialized:
        self.setup(args, state, model)
    if state.is_world_process_zero:
        logs = rewrite_logs(logs)
        self._wandb.log({**logs, "train/global_step": state.global_step}) `So I'm looking for something similar for Clearml.