blaxel 0.1.21rc69__py3-none-any.whl → 0.2.0rc1__py3-none-any.whl

blaxel/telemetry/instrumentation/blaxel_langgraph_gemini.py

@@ -0,0 +1,360 @@
+"""OpenTelemetry Google Generative AI API instrumentation"""
+
+import logging
+import os
+import types
+from typing import Collection
+
+from opentelemetry import context as context_api
+from opentelemetry.instrumentation.google_generativeai.config import Config
+from opentelemetry.instrumentation.google_generativeai.utils import dont_throw
+from opentelemetry.instrumentation.google_generativeai.version import __version__
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
+from opentelemetry.semconv_ai import (
+    SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
+    LLMRequestTypeValues,
+    SpanAttributes,
+)
+from opentelemetry.trace import SpanKind, get_tracer
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import wrap_function_wrapper
+
+logger = logging.getLogger(__name__)
+
+WRAPPED_METHODS = [
+    {
+        "package": "blaxel_langgraph.custom.gemini",
+        "object": "GeminiRestClient",
+        "method": "generate_content",
+        "span_name": "gemini.generate_content",
+    },
+    {
+        "package": "blaxel_langgraph.custom.gemini",
+        "object": "GeminiRestClient",
+        "method": "generate_content_async",
+        "span_name": "gemini.generate_content_async",
+    },
+]
+
+
+def should_send_prompts():
+    return (
+        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
+
+def is_streaming_response(response):
+    return isinstance(response, types.GeneratorType)
+
+
+def is_async_streaming_response(response):
+    return isinstance(response, types.AsyncGeneratorType)
+
+
+def _set_span_attribute(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+def _set_input_attributes(span, args, kwargs, llm_model):
+    if not should_send_prompts():
+        return
+
+    if "contents" in kwargs:
+        contents = kwargs["contents"]
+        if isinstance(contents, list):
+            for i, content in enumerate(contents):
+                if hasattr(content, "parts"):
+                    for part in content.parts:
+                        if hasattr(part, "text"):
+                            _set_span_attribute(
+                                span,
+                                f"{SpanAttributes.LLM_PROMPTS}.{i}.content",
+                                part.text,
+                            )
+                            _set_span_attribute(
+                                span,
+                                f"{SpanAttributes.LLM_PROMPTS}.{i}.role",
+                                getattr(content, "role", "user"),
+                            )
+    elif args and len(args) > 0:
+        prompt = ""
+        for arg in args:
+            if isinstance(arg, str):
+                prompt = f"{prompt}{arg}\n"
+            elif isinstance(arg, list):
+                for subarg in arg:
+                    prompt = f"{prompt}{subarg}\n"
+        if prompt:
+            _set_span_attribute(
+                span,
+                f"{SpanAttributes.LLM_PROMPTS}.0.content",
+                prompt,
+            )
+            _set_span_attribute(
+                span,
+                f"{SpanAttributes.LLM_PROMPTS}.0.role",
+                "user",
+            )
+    elif "prompt" in kwargs:
+        _set_span_attribute(
+            span,
+            f"{SpanAttributes.LLM_PROMPTS}.0.content",
+            kwargs["prompt"],
+        )
+        _set_span_attribute(
+            span,
+            f"{SpanAttributes.LLM_PROMPTS}.0.role",
+            "user",
+        )
+
+    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, llm_model)
+    _set_span_attribute(
+        span, SpanAttributes.LLM_REQUEST_TEMPERATURE, kwargs.get("temperature")
+    )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_output_tokens")
+    )
+    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_TOP_P, kwargs.get("top_p"))
+    _set_span_attribute(span, SpanAttributes.LLM_TOP_K, kwargs.get("top_k"))
+    _set_span_attribute(
+        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
+    )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
+    )
+
+    return
+
+
+@dont_throw
+def _set_response_attributes(span, response, llm_model):
+    _set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, llm_model)
+
+    if hasattr(response, "usage_metadata"):
+        _set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+            response.usage_metadata.total_token_count,
+        )
+        _set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+            response.usage_metadata.candidates_token_count,
+        )
+        _set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+            response.usage_metadata.prompt_token_count,
+        )
+
+        if isinstance(response.text, list):
+            for index, item in enumerate(response):
+                prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+                _set_span_attribute(span, f"{prefix}.content", item.text)
+                _set_span_attribute(span, f"{prefix}.role", "assistant")
+        elif isinstance(response.text, str):
+            _set_span_attribute(
+                span, f"{SpanAttributes.LLM_COMPLETIONS}.0.content", response.text
+            )
+            _set_span_attribute(
+                span, f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant"
+            )
+    else:
+        if isinstance(response, list):
+            for index, item in enumerate(response):
+                prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+                _set_span_attribute(span, f"{prefix}.content", item)
+                _set_span_attribute(span, f"{prefix}.role", "assistant")
+        elif isinstance(response, str):
+            _set_span_attribute(
+                span, f"{SpanAttributes.LLM_COMPLETIONS}.0.content", response
+            )
+            _set_span_attribute(
+                span, f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant"
+            )
+
+    return
+
+
+def _build_from_streaming_response(span, response, llm_model):
+    complete_response = ""
+    for item in response:
+        item_to_yield = item
+        complete_response += str(item.text)
+
+        yield item_to_yield
+
+    _set_response_attributes(span, complete_response, llm_model)
+
+    span.set_status(Status(StatusCode.OK))
+    span.end()
+
+
+async def _abuild_from_streaming_response(span, response, llm_model):
+    complete_response = ""
+    async for item in response:
+        item_to_yield = item
+        complete_response += str(item.text)
+
+        yield item_to_yield
+
+    _set_response_attributes(span, complete_response, llm_model)
+
+    span.set_status(Status(StatusCode.OK))
+    span.end()
+
+
+# @dont_throw
+def _handle_request(span, args, kwargs, llm_model):
+    if span.is_recording():
+        _set_input_attributes(span, args, kwargs, llm_model)
+
+
+@dont_throw
+def _handle_response(span, response, llm_model):
+    if span.is_recording():
+        _set_response_attributes(span, response, llm_model)
+
+        span.set_status(Status(StatusCode.OK))
+
+
+def _with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer
+
+
+@_with_tracer_wrapper
+async def _awrap(tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Instruments and calls every function defined in TO_WRAP."""
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
+        SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
+    ):
+        return await wrapped(*args, **kwargs)
+
+    llm_model = "unknown"
+    if hasattr(instance, "_model_id"):
+        llm_model = instance._model_id.replace("models/", "")
+    if hasattr(instance, "_model_name"):
+        llm_model = instance._model_name.replace(
+            "publishers/google/models/", ""
+        ).replace("models/", "")
+    if hasattr(instance, "model") and hasattr(instance.model, "model_name"):
+        llm_model = instance.model.model_name.replace("models/", "")
+
+    name = to_wrap.get("span_name")
+    span = tracer.start_span(
+        name,
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.LLM_SYSTEM: "Gemini",
+            SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
+        },
+    )
+
+    _handle_request(span, args, kwargs, llm_model)
+
+    response = await wrapped(*args, **kwargs)
+
+    if response:
+        if is_streaming_response(response):
+            return _build_from_streaming_response(span, response, llm_model)
+        elif is_async_streaming_response(response):
+            return _abuild_from_streaming_response(span, response, llm_model)
+        else:
+            _handle_response(span, response, llm_model)
+
+    span.end()
+    return response
+
+
+@_with_tracer_wrapper
+def _wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Instruments and calls every function defined in TO_WRAP."""
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
+        SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
+    ):
+        return wrapped(*args, **kwargs)
+
+    llm_model = "unknown"
+    if hasattr(instance, "_model_id"):
+        llm_model = instance._model_id.replace("models/", "")
+    if hasattr(instance, "_model_name"):
+        llm_model = instance._model_name.replace(
+            "publishers/google/models/", ""
+        ).replace("models/", "")
+    if hasattr(instance, "model") and hasattr(instance.model, "model_name"):
+        llm_model = instance.model.model_name.replace("models/", "")
+
+    name = to_wrap.get("span_name")
+    span = tracer.start_span(
+        name,
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.LLM_SYSTEM: "Gemini",
+            SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
+        },
+    )
+
+    _handle_request(span, args, kwargs, llm_model)
+
+    response = wrapped(*args, **kwargs)
+
+    if response:
+        if is_streaming_response(response):
+            return _build_from_streaming_response(span, response, llm_model)
+        elif is_async_streaming_response(response):
+            return _abuild_from_streaming_response(span, response, llm_model)
+        else:
+            _handle_response(span, response, llm_model)
+
+    span.end()
+    return response
+
+
+class BlaxelLanggraphGeminiInstrumentor(BaseInstrumentor):
+    """An instrumentor for Google Generative AI's client library."""
+
+    def __init__(self, exception_logger=None):
+        super().__init__()
+        Config.exception_logger = exception_logger
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["blaxel_langgraph"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+
+            wrap_function_wrapper(
+                wrap_package,
+                f"{wrap_object}.{wrap_method}",
+                (
+                    _awrap(tracer, wrapped_method)
+                    if wrap_method == "generate_content_async"
+                    else _wrap(tracer, wrapped_method)
+                ),
+            )
+
+    def _uninstrument(self, **kwargs):
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            unwrap(
+                f"{wrap_package}.{wrap_object}",
+                wrapped_method.get("method", ""),
+            )

blaxel/telemetry/instrumentation/blaxel_llamaindex.py

@@ -0,0 +1,89 @@
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as package_version
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    process_request,
+    process_response,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
+TO_INSTRUMENT = [
+    {
+        "class": "FunctionTool",
+        "v9_module": "llama_index.tools.function_tool",
+        "v10_module": "llama_index.core.tools.function_tool",
+        "v10_legacy_module": "llama_index.legacy.tools.function_tool",
+    },
+    {
+        "class": "QueryEngineTool",
+        "v9_module": "llama_index.tools.query_engine",
+        "v10_module": "llama_index.core.tools.query_engine",
+        "v10_legacy_module": "llama_index.legacy.tools.query_engine",
+    },
+]
+
+
+class BlaxelLlamaIndexInstrumentor(BaseInstrumentor):
+    def instrumentation_dependencies(self):
+        return ["blaxel_llamaindex", "blaxel.core"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "0.2.0", tracer_provider)
+
+        for module in TO_INSTRUMENT:
+            try:
+                package_version("llama-index-core")
+                self._instrument_module(module["v10_module"], module["class"], tracer)
+                self._instrument_module(module["v10_legacy_module"], module["class"], tracer)
+
+            except PackageNotFoundError:
+                self._instrument_module(module["v9_module"], module["class"], tracer)
+
+    def _uninstrument(self, **kwargs):
+        pass
+
+    def _instrument_module(self, module_name, class_name, tracer):
+        wrap_function_wrapper(
+            module_name, f"{class_name}.call", query_wrapper(tracer)
+        )
+        wrap_function_wrapper(
+            module_name, f"{class_name}.acall", aquery_wrapper(tracer)
+        )
+
+
+@_with_tracer_wrapper
+def query_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    with tracer.start_as_current_span(f"{name}.tool") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TOOL.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res
+
+
+@_with_tracer_wrapper
+async def aquery_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    async with start_as_current_span_async(tracer=tracer, name=f"{name}.tool") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TOOL.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = await wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res

blaxel/telemetry/instrumentation/map.py

@@ -0,0 +1,61 @@
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+
+class InstrumentationMapping(BaseModel):
+    module_path: str
+    class_name: str
+    required_packages: List[str]
+    ignore_if_packages: List[str]
+
+MAPPINGS: Dict[str, InstrumentationMapping] = {
+    "anthropic": InstrumentationMapping(
+        module_path="opentelemetry.instrumentation.anthropic",
+        class_name="AnthropicInstrumentor",
+        required_packages=["anthropic"],
+        ignore_if_packages=[]
+    ),
+    "cohere": InstrumentationMapping(
+        module_path="opentelemetry.instrumentation.cohere",
+        class_name="CohereInstrumentor",
+        required_packages=["cohere"],
+        ignore_if_packages=[]
+    ),
+    "openai": InstrumentationMapping(
+        module_path="opentelemetry.instrumentation.openai",
+        class_name="OpenAIInstrumentor",
+        required_packages=["openai"],
+        ignore_if_packages=[]
+    ),
+    "gemini": InstrumentationMapping(
+        module_path="opentelemetry.instrumentation.google_generativeai",
+        class_name="GoogleGenerativeAIInstrumentor",
+        required_packages=["google-generativeai"],
+        ignore_if_packages=[]
+    ),
+    "blaxel.core": InstrumentationMapping(
+        module_path="blaxel_telemetry.instrumentation.blaxel.core",
+        class_name="BlaxelCoreInstrumentor",
+        required_packages=["blaxel.core"],
+        ignore_if_packages=[]
+    ),
+    "blaxel_langgraph": InstrumentationMapping(
+        module_path="blaxel_telemetry.instrumentation.blaxel_langgraph",
+        class_name="BlaxelLanggraphInstrumentor",
+        required_packages=["blaxel_langgraph"],
+        ignore_if_packages=[]
+    ),
+    "blaxel_langgraph_gemini": InstrumentationMapping(
+        module_path="blaxel_telemetry.instrumentation.blaxel_langgraph_gemini",
+        class_name="BlaxelLanggraphGeminiInstrumentor",
+        required_packages=["blaxel_langgraph"],
+        ignore_if_packages=[]
+    ),
+    "blaxel_llamaindex": InstrumentationMapping(
+        module_path="blaxel_telemetry.instrumentation.blaxel_llamaindex",
+        class_name="BlaxelLlamaIndexInstrumentor",
+        required_packages=["blaxel_llamaindex"],
+        ignore_if_packages=[]
+    ),
+}

blaxel/telemetry/instrumentation/utils.py

@@ -0,0 +1,74 @@
+import dataclasses
+import json
+import logging
+import os
+import traceback
+from contextlib import asynccontextmanager
+
+from opentelemetry.semconv_ai import SpanAttributes
+
+
+def dont_throw(func):
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            logger.debug(
+                "Instrumentation failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+
+    return wrapper
+
+
+def with_tracer_wrapper(func):
+    def _with_tracer(tracer):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer
+
+
+@asynccontextmanager
+async def start_as_current_span_async(tracer, *args, **kwargs):
+    with tracer.start_as_current_span(*args, **kwargs) as span:
+        yield span
+
+class JSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        if dataclasses.is_dataclass(o):
+            return dataclasses.asdict(o)
+        elif hasattr(o, "json"):
+            return o.json()
+        elif hasattr(o, "to_json"):
+            return o.to_json()
+        return super().default(o)
+
+
+def should_send_prompts():
+    return (
+        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+    ).lower() == "true"
+
+@dont_throw
+def process_request(span, args, kwargs):
+    if should_send_prompts():
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_ENTITY_INPUT,
+            json.dumps({"args": args, "kwargs": kwargs}, cls=JSONEncoder),
+        )
+
+
+@dont_throw
+def process_response(span, res):
+    if should_send_prompts():
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_ENTITY_OUTPUT,
+            json.dumps(res, cls=JSONEncoder),
+        )

blaxel/{common → telemetry/log}/logger.py

@@ -6,7 +6,7 @@ import json
 import logging
 import os
 
-from opentelemetry.trace import get_current_span
+from opentelemetry import trace
 
 
 class JsonFormatter(logging.Formatter):
@@ -35,18 +35,12 @@ class JsonFormatter(logging.Formatter):
             self.labels_name: {}
         }
 
-        # Get current active span - equivalent to trace.getActiveSpan() in JS
-        current_span = get_current_span()
-        
-        # Check if span exists and has valid context (equivalent to 'if (currentSpan)' in JS)
-        if current_span and current_span.get_span_context().is_valid:
+        # Add trace context if available
+        current_span = trace.get_current_span()
+        if current_span.is_recording():
             span_context = current_span.get_span_context()
-            # Format trace_id and span_id as hex strings (like JS does)
-            trace_id_hex = format(span_context.trace_id, '032x')
-            span_id_hex = format(span_context.span_id, '016x')
-            
-            log_entry[self.trace_id_name] = f"{self.trace_id_prefix}{trace_id_hex}"
-            log_entry[self.span_id_name] = f"{self.span_id_prefix}{span_id_hex}"
+            log_entry[self.trace_id_name] = f"{self.trace_id_prefix}{span_context.trace_id}"
+            log_entry[self.span_id_name] = f"{self.span_id_prefix}{span_context.span_id}"
 
         # Add task ID if available
         task_id = os.environ.get(self.task_index)

blaxel/{instrumentation → telemetry}/manager.py

@@ -21,16 +21,16 @@ from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.trace import NoOpTracerProvider
 
-from blaxel.instrumentation.exporters import (
+from blaxel.core.common import Settings
+
+from .exporters import (
     DynamicHeadersLogExporter,
     DynamicHeadersMetricExporter,
     DynamicHeadersSpanExporter,
 )
-from blaxel.instrumentation.span import DefaultAttributesSpanProcessor
-
-from ..common.settings import Settings
-from .log import AsyncLogRecordProcessor
-from .map import MAPPINGS
+from .instrumentation.map import MAPPINGS
+from .log.log import AsyncLogRecordProcessor
+from .span import DefaultAttributesSpanProcessor
 
 logger = logging.getLogger(__name__)
 
@@ -116,6 +116,7 @@ class TelemetryManager:
 
     def setup_signal_handler(self):
         """Set up signal handlers for graceful shutdown."""
+
         def handle_signal(signum, frame):
             logger.debug(f"Received signal {signum}")
             self.shutdown()
@@ -150,11 +151,15 @@ class TelemetryManager:
         # Set up the TracerProvider
         trace_provider = TracerProvider(resource=resource)
         span_processor = BatchSpanProcessor(self.get_span_exporter())
-        trace_provider.add_span_processor(DefaultAttributesSpanProcessor({
-            "workload.id": self.resource_name,
-            "workload.type": self.resource_type,
-            "workspace": self.resource_workspace,
-        }))
+        trace_provider.add_span_processor(
+            DefaultAttributesSpanProcessor(
+                {
+                    "workload.id": self.resource_name,
+                    "workload.type": self.resource_type,
+                    "workspace": self.resource_workspace,
+                }
+            )
+        )
         trace_provider.add_span_processor(span_processor)
         trace.set_tracer_provider(trace_provider)
         self.tracer = trace_provider.get_tracer(__name__)
@@ -217,10 +222,13 @@ class TelemetryManager:
             if time.time() - start_time < timeout:
                 logger.debug("Instrumentation shutdown complete")
             else:
-                logger.warning("Shutdown timed out after 5 seconds, skipping remaining shutdown tasks")
+                logger.warning(
+                    "Shutdown timed out after 5 seconds, skipping remaining shutdown tasks"
+                )
 
         except Exception as error:
             logger.error(f"Error during shutdown: {error}")
 
+
 # Create a singleton instance
 telemetry_manager = TelemetryManager()