Moving Mountains, DevOpsDays Tel Aviv 2025 (companion)

01_README.md

Moving Mountains

Presentation at DevOpsDays Tel Aviv 2025

Speaker: Mike Fiedler

Directory

• 01_README.md (this file)
• 02_sample_utils.py - example utility library with semi-working tools like a deprecation decorator and a subclass of laboratory.Experiment
• 03_some_module_a.py - example of a module with a deprecated function
• 03_some_module_b.py - same module, with an experiment
• 03_some_module_c.py - same module, cleaned up to use new function only

Links

• https://www.python.org/psf-landing/
• https://pypi.org/
• https://blog.pypi.org/
• https://this-page-intentionally-left-blank.org
• https://codeinthehole.com/
• https://books.wiley.com/authors/len-silverston/
• https://martinfowler.com/bliki/StranglerFigApplication.html
• https://www.structlog.org/
• https://graphviz.org/
• https://www.postgresql.org/docs/current/monitoring-stats.html
• https://www.datadoghq.com/blog/postgresql-monitoring-tools/
• https://github.blog/developer-skills/application-development/scientist/
• https://github.com/github/scientist
• https://pypi.org/project/laboratory/
• https://zepworks.com/deepdiff/8.6.1/

Extra!

https://martinfowler.com/articles/is-quality-worth-cost.html

02_utils_sample.py

"""
Sample utils module (not expected to work)
"""

import functools
import logging
import traceback

from laboratory import Experiment

_log = logging.getLogger(__name__)


def deprecated(fn):
    """
    Incomplete example of a deprecation tracker decorator.
    Other solutions exist in the wild, including a built-in from Python 3.13 onwards.

    This one in particular uses a `log_with_traceback()` function
    that is not shared that logs the emitted warning including 
    up to 10 lines of the traceback to aid in tracking down callers.

    - https://pypi.org/project/Deprecated/
    - https://docs.python.org/3.13/library/warnings.html#warnings.deprecated
    """
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        err = DeprecationWarning(fn.__name__)
        exc_lines = traceback.format_exception_only(type(err), err)
        log_dict = {
            'msg': 'call_to_deprecated_function',
            'qualname': fn.__qualname__,
            'module': fn.__module__,
            'name': fn.__name__,
        }
        log_with_traceback(
            log_dict, extra_stack=exc_lines,
            offset=1, limit=10,
        )
        return fn(*args, **kwargs)
    return wrapper


class Probe(Experiment):
    def __init__(self, enable_probing, *args, **kwargs):
        self.enable_probing = enable_probing
        self.compare_results = None
        super().__init__(*args, **kwargs)

    def enabled(self):
        return self.enable_probing

    def publish(self, result):
        if not result.match:
            _log.warning(
            {
                'evt': "probe_result_mismatch",
                'msg': f"results did not match for probe: {self.name}",
                'probe_name': self.name,
                    'control': {
                        'function_name': result.control.name,
                        'exception': result.control.exception,
                        'context': result.control.get_context(),
                        'value': result.control.value,
                    },
                    'candidates': {
                        i: {
                            'function_name': candidate.name,
                            'exception': candidate.exception,
                            'exc_info': candidate.exc_info,
                            'value': candidate.value,
                            'diff': deepdiff.DeepDiff(
                                result.control.value,
                                candidate.value,
                                verbose_level=0,
                            ),
                        } for i, candidate in enumerate(result.candidates)
                    },
                }
            )

        self._emit_metric(self.name, result.control.name, result.control.duration)
        for candidate in result.candidates:
            self._emit_metric(self.name, candidate.name, candidate.duration)

# Alternate implementation of `publish()` that uses console printing, and no deep-diffing.
#     def publish(self, result):
#         if not result.match:
#             print("Probe mismatch detected:", result)
#         for candidate in result.candidates:
#             print("candidate func\t{}\t{}".format(candidate.name, candidate.duration))
#         print("control func\t{}\t{}".format(result.control.name, result.control.duration))

03_some_module_a.py

import time
from utils import deprecated

class SomeModule:
    @deprecated
    def some_function(self):
        time.sleep(4)
        return "Deprecated Function Called"


def function_call():
    module = SomeModule()
    return module.some_function()

03_some_module_b.py

import time
from utils import deprecated, Probe

class SomeModule:
    @deprecated
    def some_function(self):
        time.sleep(4)
        return "Deprecated Function Called"

    def some_new_function(self):
        return "New Function Called"


def function_call():
    module = SomeModule()

    probe = Probe(name="Example Refactor")
    probe.control(module.some_function, name="some_function")
    probe.candidate(module.some_new_function, name="some_new_function")

    response = probe.conduct()
    return response

03_some_module_c.py

class SomeModule:
    def some_function(self):
        return "New Function Called"

def function_call():
    module = SomeModule()
    return module.some_function()